home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / Drtf / DDrawPICT.cpp < prev    next >
Text File  |  1996-07-05  |  62KB  |  2,413 lines
  1. // DDrawPICT.cpp
  2. //  translate Mac QuickDraw PICT data format to NCBI Draw methods 
  3.  
  4.  
  5. // debugging -- file list
  6. #undef PLIST
  7.  
  8. #include <ncbi.h>
  9. #include <ncbidraw.h>
  10. #include <ncbiwin.h>
  11. #include <ncbiport.h>
  12. #include <vibtypes.h>
  13. #include <vibincld.h>
  14.  
  15. // avoid mess with document.h
  16. #define _DOCUMENT_
  17.  
  18. #include "Dvibrant.h"
  19. #include "DDrawPICT.h"
  20.  
  21. #ifdef WIN_MAC
  22. #include <Palettes.h>
  23. #endif
  24.  
  25. #define byte             unsigned char
  26. #define word             unsigned short
  27. #define longword     unsigned long
  28.  
  29.  
  30. #ifdef PLIST
  31. FILE* gPlist= NULL;
  32. Boolean gDoPlist = true;
  33. #endif
  34.  
  35.  
  36.  
  37. enum PICTops {
  38.     oNOP =    0,
  39.     oClip,
  40.     oBkPat,
  41.     oTxFont,
  42.     oTxFace,
  43.     oTxMode,
  44.     oSpExtra,
  45.     oPnSize,
  46.     oPnMode,
  47.     oPnPat,
  48.     oFillPat,
  49.     oOvSize,
  50.     oOrigin,
  51.     oTxSize,
  52.     oFgColor,
  53.     oBkColor,
  54.     oTxRatio,
  55.     oVersion,
  56.     oBkPixPat,
  57.     oPnPixPat,
  58.     oFillPixPat,
  59.     oPnLocHFrac,
  60.     oChExtra,
  61.     r17,r18,r19,
  62.     oRGBFgCol    = 0x1a,
  63.     oRGBBkCol,
  64.     oHiliteMode,
  65.     oHiliteColor,
  66.     oDefHilite,
  67.     oOpColor,
  68.     oLine,
  69.     oLineFrom,
  70.     oShortLine,
  71.     oShortLineFrom,
  72.     r24,r25,r26,r27,
  73.     oLongText    = 0x28,
  74.     oDHText,
  75.     oDVText,
  76.     oDHDVText,
  77.     oFontName, /* was res2c */
  78.     r2d,
  79.     or2e_mov,  /* was res2e -- just a GUESS !!! */
  80.     r2f,
  81.     oframeRect    = 0x30,
  82.     opaintRect,
  83.     oeraseRect,
  84.     oinvertRect,
  85.     ofillRect,
  86.     r35,r36,r37,
  87.     oframeSameRect = 0x38,
  88.     opaintSameRect,
  89.     oeraseSameRect,
  90.     oinvertSameRect,
  91.     ofillSameRect,
  92.     r3d,r3e,r3f,
  93.     oframeRRect     = 0x40,
  94.     opaintRRect,
  95.     oeraseRRect,
  96.     oinvertRRect,
  97.     ofillRRect,
  98.     r45,r46,r47,
  99.     oframeSameRRect    = 0x48,
  100.     opaintSameRRect,
  101.     oeraseSameRRect,
  102.     oinvertSameRRect,
  103.     ofillSameRRect,
  104.     r4d,r4e,r4f,
  105.     oframeOval = 0x50,
  106.     opaintOval,
  107.     oeraseOval,
  108.     oinvertOval,
  109.     ofillOval,
  110.     r55,r56,r57,
  111.     oframeSameOval = 0x58,
  112.     opaintSameOval,
  113.     oeraseSameOval,
  114.     oinvertSameOval,
  115.     ofillSameOval,
  116.     r5d,r5e,r5f,
  117.     oframeArc = 0x60,
  118.     opaintArc,
  119.     oeraseArc,
  120.     oinvertArc,
  121.     ofillArc,
  122.     r65,r66,r67,
  123.     oframeSameArc = 0x68,
  124.     opaintSameArc,
  125.     oeraseSameArc,
  126.     oinvertSameArc,
  127.     ofillSameArc,
  128.     r6d,r6e,r6f,
  129.     oframePoly = 0x70,
  130.     opaintPoly ,
  131.     oerasePoly,
  132.     oinvertPoly,
  133.     ofillPoly,
  134.     r75,r76,r77,
  135.     oframeSamePoly = 0x78,
  136.     opaintSamePoly,
  137.     oeraseSamePoly,
  138.     oinvertSamePoly,
  139.     ofillSamePoly,
  140.     r7d,r7e,r7f,
  141.     oframeRgn = 0x80,
  142.     opaintRgn,
  143.     oeraseRgn,
  144.     oinvertRgn,
  145.     ofillRgn,
  146.     r85,r86,r87,
  147.     oframeSameRgn = 0x88,
  148.     opaintSameRgn,
  149.     oeraseSameRgn,
  150.     oinvertSameRgn,
  151.     ofillSameRgn,
  152.     r8d,r8e,r8f,
  153.     oBitsRect = 0x90,
  154.     oBitsRgn,
  155.     r92,r93,r94,r95,r96,r97,
  156.     oPackBitsRect = 0x98,
  157.     oPackBitsRgn,
  158.     oOpcode9A,
  159.     r9b,r9c,r9d,r9e,r9f,
  160.     oShortComment = 0xa0,
  161.     oLongComment,
  162.     /* a2..af,b0..fe unused */
  163.     oopEndPic    = 0x00ff,
  164.     /* 0100..ffff unused */
  165.     oHeaderOp    = 0x0c00
  166.     };
  167.     
  168.  
  169. #ifdef PLIST
  170. static char* gOpnames[] = {
  171.  "oNOP",
  172.  "oClip",
  173.  "oBkPat",
  174.  "oTxFont",
  175.  "oTxFace",
  176.  "oTxMode",
  177.  "oSpExtra",
  178.  "oPnSize",
  179.  "oPnMode",
  180.  "oPnPat",
  181.  "oFillPat",
  182.  "oOvSize",
  183.  "oOrigin",
  184.  "oTxSize",
  185.  "oFgColor",
  186.  "oBkColor",
  187.  "oTxRatio",
  188.  "oVersion",
  189.  "oBkPixPat",
  190.  "oPnPixPat",
  191.  "oFillPixPat",
  192.  "oPnLocHFrac",
  193.  "oChExtra",
  194.  "r17","r18","r19",
  195.  "oRGBFgCol",
  196.  "oRGBBkCol",
  197.  "oHiliteMode",
  198.  "oHiliteColor",
  199.  "oDefHilite",
  200.  "oOpColor",
  201.  "oLine",
  202.  "oLineFrom",
  203.  "oShortLine",
  204.  "oShortLineFrom",
  205.     "r24","r25","r26","r27",
  206.  "oLongText",
  207.  "oDHText",
  208.  "oDVText",
  209.  "oDHDVText",
  210.  "oFontName",  
  211.     "r2d",
  212.  "or2e_mov", 
  213.     "r2f",
  214.  "oframeRect",
  215.  "opaintRect",
  216.  "oeraseRect",
  217.  "oinvertRect",
  218.  "ofillRect",
  219.     "r35","r36","r37",
  220.  "oframeSameRect",
  221.  "opaintSameRect",
  222.  "oeraseSameRect",
  223.  "oinvertSameRect",
  224.  "ofillSameRect",
  225.     "r3d","r3e","r3f",
  226.  "oframeRRect",
  227.  "opaintRRect",
  228.  "oeraseRRect",
  229.  "oinvertRRect",
  230.  "ofillRRect",
  231.     "r45","r46","r47",
  232.  "oframeSameRRect",
  233.  "opaintSameRRect",
  234.  "oeraseSameRRect",
  235.  "oinvertSameRRect",
  236.  "ofillSameRRect",
  237.     "r4d","r4e","r4f",
  238.  "oframeOval",
  239.  "opaintOval",
  240.  "oeraseOval",
  241.  "oinvertOval",
  242.  "ofillOval",
  243.     "r55","r56","r57",
  244.  "oframeSameOval",
  245.  "opaintSameOval",
  246.  "oeraseSameOval",
  247.  "oinvertSameOval",
  248.  "ofillSameOval",
  249.     "r5d","r5e","r5f",
  250.  "oframeArc",
  251.  "opaintArc",
  252.  "oeraseArc",
  253.  "oinvertArc",
  254.  "ofillArc",
  255.     "r65","r66","r67",
  256.  "oframeSameArc",
  257.  "opaintSameArc",
  258.  "oeraseSameArc",
  259.  "oinvertSameArc",
  260.  "ofillSameArc",
  261.     "r6d","r6e","r6f",
  262.  "oframePoly",
  263.  "opaintPoly",
  264.  "oerasePoly",
  265.  "oinvertPoly",
  266.  "ofillPoly",
  267.     "r75","r76","r77",
  268.  "oframeSamePoly",
  269.  "opaintSamePoly",
  270.  "oeraseSamePoly",
  271.  "oinvertSamePoly",
  272.  "ofillSamePoly",
  273.     "r7d","r7e","r7f",
  274.  "oframeRgn",
  275.  "opaintRgn",
  276.  "oeraseRgn",
  277.  "oinvertRgn",
  278.  "ofillRgn",
  279.     "r85","r86","r87",
  280.  "oframeSameRgn",
  281.  "opaintSameRgn",
  282.  "oeraseSameRgn",
  283.  "oinvertSameRgn",
  284.  "ofillSameRgn",
  285.     "r8d","r8e","r8f",
  286.  "oBitsRect",
  287.  "oBitsRgn",
  288.     "r92","r93","r94","r95","r96","r97",
  289.  "oPackBitsRect",
  290.  "oPackBitsRgn",
  291.  "oOpcode9A",
  292.     "r9b","r9c","r9d","r9e","r9f",
  293.  "oShortComment",
  294.  "oLongComment",
  295.   0 };
  296.  
  297. //    /* a2..af",b0..fe unused */
  298. // "oopEndPic    = 0x00ff",
  299. //    /* 0100..ffff unused */
  300. // "oHeaderOp    = 0x0c00
  301. #endif
  302.     
  303.     
  304. typedef struct valName {
  305.     short    value;
  306.     char* name;
  307. } ValName;
  308.  
  309. static ValName QuickDrawFont[] = {
  310.     { 0,    "helvetica" },     /* Chicago */
  311.     { 1,    "helvetica" },  /* Geneva */
  312.     { 2,    "times" },            /* newYork */
  313.     { 3,    "helvetica" },    /* geneva */
  314.     { 4,    "courier" },        /* monaco */
  315.     { 5,    "times" },            /* venice */
  316.     { 6,    "times" },            /* london */
  317.     { 7,    "times" },            /* athens */
  318.     { 8,    "times" },            /* sanFran */
  319.     { 9,    "times" },            /* toronto */
  320.     { 11,    "times" },            /* cairo */
  321.     { 12,    "times" },            /* losAngeles */
  322.     { 13,    "times" },            /* Zapf Dingbats */
  323.     { 14,    "bookman" },        /* bookman */
  324.     { 16,    "palatino" },        /* palatino */
  325.     { 18,    "times" },            /* Zapf Chancery */
  326.     { 19,    "times" },            /* Sourvenir */
  327.     { 20,    "times" },            /* times */
  328.     { 21,    "helvetica" },
  329.     { 22,    "courier" },
  330.     { 23,    "symbol" },
  331.     { 24,    "times" },         /* taliesin */
  332.     { 26,    "times" },         /* Lubalin Graph */
  333.     { 33,    "avant garde" },         /* Avant Garde */
  334.     { 34,    "New Century Schlbk" },         /* New Century Schlbk */
  335.     { -1,    0 }
  336. };
  337.  
  338. #if 0
  339. Font[0] = 'Chicago'
  340. Font[1] = 'Geneva'
  341. Font[2] = 'New York'
  342. Font[3] = 'Geneva'
  343. Font[4] = 'Monaco'
  344. Font[13] = 'Zapf Dingbats'
  345. Font[14] = 'Bookman'
  346. Font[16] = 'Palatino'
  347. Font[18] = 'Zapf Chancery'
  348. Font[19] = 'Souvenir'
  349. Font[20] = 'Times'
  350. Font[21] = 'Helvetica'
  351. Font[22] = 'Courier'
  352. Font[23] = 'Symbol'
  353. Font[26] = 'Lubalin Graph'
  354. Font[33] = 'Avant Garde'
  355. Font[34] = 'New Century Schlbk'
  356. #endif
  357.     
  358.  
  359. Nlm_Boolean gPixColorsDone = false; // a hack !
  360.  
  361. #ifdef WIN_MOTIF
  362. static short gAllocatedColors[256];
  363. static short gNAllocatedColors = 0;
  364. #endif
  365.  
  366.  
  367. DDrawPict::DDrawPict() :
  368.     fVerbose(true), fPenshown(true), fUnclipped(true),
  369.     fPict(NULL), fAlign(0),
  370.     fFont(NULL), fFontname(NULL), fFontfamily(NULL),
  371.     fFontsize(12), fFontstyle(0), fLastFontnum(-1),
  372.     fNeedInstallFont(false),
  373.     fPictVersion(0), fPicsize(0)
  374. {
  375.     Nlm_LoadRect( &fPicRect, 0, 0, 0, 0);
  376.     Nlm_LoadRect( &fPicFrame, 0, 0, 0, 0);
  377.     Nlm_LoadRect( &fTheRect, 0, 0, 0, 0);
  378.     fOvSize.x= 0; 
  379.     fOvSize.y= 0;
  380.     fFontname= "Times";
  381.     fFontfamily= "Roman";
  382.     MakeXByteFlip();
  383.   gPixColorsDone= false;
  384. }
  385.  
  386. DDrawPict::~DDrawPict()
  387. {
  388.  
  389. }
  390.  
  391. //static
  392. void DDrawPict::Cleanup()
  393. {
  394. #ifdef WIN_MOTIF
  395.     if (gNAllocatedColors) {
  396.         short     i, j;
  397.       Display * display     = Nlm_currentXDisplay;
  398.       short     screenNum    = DefaultScreen( display);
  399.        Visual  * visual        = DefaultVisual( display, screenNum);
  400.        Colormap     colormap     = DefaultColormap( display, screenNum);  
  401.          
  402.         for (i=0; i<256; i++) {
  403.             short nalloc= gAllocatedColors[i];
  404.             unsigned long pixel= i;
  405.             for ( ; nalloc>0; nalloc--) 
  406.                 XFreeColors( display, colormap, &pixel, 1, 0L);
  407.             gAllocatedColors[i]= 0;
  408.             }
  409.         gNAllocatedColors= 0;
  410.         }
  411. #endif    
  412. }
  413.  
  414.  
  415.  
  416. byte    DDrawPict::getByte()
  417. {
  418.     byte b = *fPict++;
  419.     fAlign++;
  420. #ifdef PLIST
  421.     if (gDoPlist) fprintf( gPlist, " %2X", b); 
  422. #endif
  423.     return b;
  424. }
  425.  
  426. word DDrawPict::getWord()
  427. {
  428.     word b = *fPict++;
  429.     fAlign += 2;
  430.     b=  (b << 8) | *fPict++;
  431. #ifdef PLIST
  432.     if (gDoPlist) fprintf( gPlist, " %4X", b); 
  433. #endif
  434.     return b;
  435. }
  436.  
  437. longword DDrawPict::getLong()
  438. {
  439.     longword i = getWord();
  440.     i=  (i << 16) | getWord();
  441.     return i;
  442. }
  443.  
  444.  
  445. void DDrawPict::skipbytes( word count)
  446. {
  447. #ifdef PLIST
  448.     if (gDoPlist) {
  449.     fprintf( gPlist, " (skip %d)", count); 
  450.     for (short i=0; i< MIN(count,10); i++)
  451.         fprintf(gPlist, " %2X", fPict[i]);
  452.     }
  453. #endif
  454.     fAlign += count;
  455.     fPict += count;
  456. }
  457.  
  458. void DDrawPict::getbytes(char* buf, long bufsize)
  459. {
  460. #ifdef PLIST
  461.     if (gDoPlist) {
  462.     fprintf( gPlist, " (get %d)", bufsize); 
  463.     for (short i=0; i< MIN(bufsize,10); i++)
  464.         fprintf(gPlist, " %2X", fPict[i]);
  465.     }
  466. #endif
  467.     fAlign += bufsize;
  468.     MemCpy(buf, fPict, bufsize);
  469.     fPict += bufsize;
  470. }
  471.  
  472. word DDrawPict::getOpcode()
  473. {
  474.     word op;
  475.     
  476. #ifdef PLIST
  477.     if (gDoPlist) fprintf( gPlist, "\n"); 
  478. #endif
  479.     if (fPictVersion == 1)
  480.         op= getByte();
  481.     else {
  482.         if (fAlign & 1) {
  483. #ifdef PLIST
  484.             Boolean savep= gDoPlist; gDoPlist= false;
  485. #endif
  486.             (void) getByte();
  487. #ifdef PLIST
  488.             gDoPlist= savep;
  489. #endif
  490.             }
  491.         op= getWord();
  492.         }
  493.         
  494. #ifdef PLIST
  495.     if (!gDoPlist) ;
  496.     else if (op < 0xa2) fprintf( gPlist, "%#7x %-16s: ", fAlign, gOpnames[op]);
  497.     else fprintf( gPlist, "%#7x %#-16x: ",fAlign, op);
  498. #endif
  499.     return op;
  500. }
  501.  
  502.  
  503.  
  504.  
  505.  
  506. void DDrawPict::getRGBKolor( RGBkolor* acolor)
  507. {
  508.     acolor->red = getWord();
  509.     acolor->green= getWord();
  510.     acolor->blue= getWord();
  511. }
  512.  
  513. void DDrawPict::getPointAsis( Nlm_PointPtr apt)
  514. {
  515.     apt->y    = getWord();
  516.     apt->x    = getWord();
  517. }
  518.  
  519. void DDrawPict::getPointLocal( Nlm_PointPtr apt)
  520. {
  521.     long y    = ((signed short) getWord()) - fPicFrame.top  + fPicRect.top;
  522.     long x    = ((signed short) getWord()) - fPicFrame.left + fPicRect.left;
  523.     apt->y= MAX(-32565, MIN(32565, y)); //y;
  524.     apt->x= MAX(-32565, MIN(32565, x)); //x;
  525. }
  526.  
  527. void DDrawPict::getRectLocal( Nlm_RectPtr arect)
  528. {
  529.     long top        = ((signed short) getWord()); top  += fPicRect.top - fPicFrame.top;
  530.     long left        = ((signed short) getWord()); left += fPicRect.left - fPicFrame.left;
  531.     long bottom    = ((signed short) getWord()); bottom += fPicRect.top - fPicFrame.top;
  532.     long right    = ((signed short) getWord()); right += fPicRect.left - fPicFrame.left;
  533.     arect->top         = MAX(-32565, MIN(32565, top));
  534.     arect->left        = MAX(-32565, MIN(32565, left)); //(signed short)left;
  535.     arect->bottom    = MAX(-32565, MIN(32565, bottom)); //(signed short)bottom;
  536.     arect->right    = MAX(-32565, MIN(32565, right)); //(signed short)right;
  537. }
  538.  
  539. void DDrawPict::getRectAsis( Nlm_RectPtr arect)
  540. {
  541.     arect->top        = getWord();
  542.     arect->left        = getWord();
  543.     arect->bottom    = getWord();
  544.     arect->right    = getWord();
  545. }
  546.  
  547.  
  548. void DDrawPict::skipPolyOrRegion(void)
  549. {
  550.     skipbytes( getWord() - 2);
  551. }
  552.  
  553.  
  554. #ifdef WIN_MOTIF
  555. #define COPY_MODE   1
  556. #define MERGE_MODE  2
  557. #define INVERT_MODE 3
  558. #define ERASE_MODE  4
  559.  
  560. static byte    XByteFlip [256];
  561.  
  562. void DDrawPict::MakeXByteFlip()
  563. {
  564.     short i, j;
  565.   byte val, inv;
  566.  
  567.   for (i = 0; i < 256; i++) {
  568.     inv = 0;
  569.     val = (byte) i;
  570.     for (j = 0; j < 8; j++) {
  571.       inv = (inv << 1);
  572.       inv += (val % 2);
  573.       val = (val >> 1);
  574.     }
  575.     XByteFlip[i] = inv;
  576.   }
  577. }
  578.  
  579. #else
  580.  
  581. void DDrawPict::MakeXByteFlip()
  582. {
  583. }
  584. #endif
  585.  
  586.  
  587. byte* DDrawPict::expandbuf(byte* buf, short* len, short bitsPerPixel)
  588. {
  589.     static byte pixbuf[256 * 8];
  590.     register byte* src;
  591.     register byte* dst;
  592.     register int i;
  593.  
  594.     src = buf;
  595.     dst = pixbuf;
  596.  
  597.     switch (bitsPerPixel) {
  598.     case 8:
  599.     case 16:
  600.     case 32:
  601.         return buf;
  602.     case 4:
  603.         for (i = 0; i < *len; i++) {
  604.             *dst++ = (*src >> 4) & 15;
  605.             *dst++ = *src++ & 15;
  606.         }
  607.         *len *= 2;
  608.         break;
  609.     case 2:
  610.         for (i = 0; i < *len; i++) {
  611.             *dst++ = (*src >> 6) & 3;
  612.             *dst++ = (*src >> 4) & 3;
  613.             *dst++ = (*src >> 2) & 3;
  614.             *dst++ = *src++ & 3;
  615.         }
  616.         *len *= 4;
  617.         break;
  618.     case 1:
  619.         for (i = 0; i < *len; i++) {
  620.             *dst++ = (*src >> 7) & 1;
  621.             *dst++ = (*src >> 6) & 1;
  622.             *dst++ = (*src >> 5) & 1;
  623.             *dst++ = (*src >> 4) & 1;
  624.             *dst++ = (*src >> 3) & 1;
  625.             *dst++ = (*src >> 2) & 1;
  626.             *dst++ = (*src >> 1) & 1;
  627.             *dst++ = *src++ & 1;
  628.         }
  629.         *len *= 8;
  630.         break;
  631.     default:
  632.         if (fVerbose) { Nlm_Message(MSG_OK,"drawpict:bad bits per pixel in expandbuf"); fVerbose= false; }
  633.     }
  634.     return pixbuf;
  635. }
  636.  
  637.  
  638. #define DONTEXPAND 1
  639.  
  640.  
  641. void DDrawPict::unpackSmallLine( long irow, unsigned char* linebuf, unsigned char* bits, unsigned char* bitsend, 
  642.                                                                     unsigned short rowBytes, short pixelSize)
  643. {
  644.     short buflen = rowBytes;
  645.     byte     abyte, *pbits, *bytepixels;
  646.     Nlm_Boolean isBitmap = pixelSize < 2;
  647.     long    j;
  648.     
  649.     getbytes((char*) linebuf, buflen);
  650. #if DONTEXPAND
  651. #ifdef WIN_MSWIN
  652.     if (!isBitmap) pbits= bitsend - irow*rowBytes;
  653.     else
  654. #endif
  655.     pbits = bits + irow*rowBytes; 
  656.     bytepixels= linebuf;
  657. #else
  658.     pbits = bits + irow * pixwidth;
  659.     bytepixels = expandbuf( linebuf, &buflen, pixelSize);
  660. #endif
  661.  
  662.     for (j = 0; j < buflen; j++) {
  663.         abyte= *bytepixels++;
  664. #ifdef WIN_MSWIN
  665.         if (isBitmap) abyte= (byte) ~abyte;
  666. #endif
  667. #ifdef WIN_MOTIF
  668.         if (isBitmap) abyte= XByteFlip[abyte];
  669. #endif
  670.         *pbits++ = abyte;
  671.         }
  672. }
  673.  
  674.  
  675. void DDrawPict::unpackBigLine( long irow, unsigned char* linebuf, unsigned char* bits, unsigned char* bitsend, 
  676.                                                                 unsigned short rowBytes, short pixelSize, short pkpixsize)
  677. {
  678.     enum { kFudgebuf = 300 };
  679.     word   buflen = rowBytes;
  680.     byte      abyte, *pbits, *bytepixels;
  681.     Nlm_Boolean isBitmap = pixelSize < 2;
  682.     long     j, k, l;
  683.     short  linelen, len;
  684.     
  685. #ifdef WIN_MSWIN
  686.     if (!isBitmap) pbits= bitsend - irow*rowBytes;
  687.     else
  688. #endif
  689.     pbits = bits + irow * rowBytes; // pixwidth; 
  690.  
  691.     if (rowBytes > 250 || pixelSize > 8)
  692.         linelen = getWord();
  693.     else
  694.         linelen = getByte();
  695.  
  696.     if (linelen >= kFudgebuf+rowBytes)   
  697.         Nlm_Message(MSG_FATAL,"DDrawPict::linelen > rowbytes");
  698.  
  699.     getbytes((char*) linebuf, linelen);
  700.     
  701.     for (j = 0; j < linelen; ) {
  702.         if (linebuf[j] & 0x80) {
  703.             len = ((linebuf[j] ^ 255) & 255) + 2;
  704.             buflen = pkpixsize;
  705. #if DONTEXPAND
  706.             bytepixels= linebuf + j+1;
  707. #else
  708.             bytepixels = expandbuf(linebuf + j+1, &buflen, pixelSize);
  709. #endif
  710.  
  711.             for (k = 0; k < len; k++) {
  712.                 for (l = 0; l < buflen; l++) {
  713.                     abyte= *bytepixels++;
  714. #ifdef WIN_MSWIN
  715.                     if (isBitmap) abyte= (byte) ~abyte;
  716. #endif
  717. #ifdef WIN_MOTIF
  718.                     if (isBitmap) abyte= XByteFlip[abyte];
  719. #endif
  720.                     *pbits++ = abyte;
  721.                     }
  722.                 bytepixels -= buflen;
  723.                 }
  724.             j += 1 + pkpixsize;
  725.             }
  726.         else {
  727.             len = (linebuf[j] & 255) + 1;
  728.             buflen = len * pkpixsize;
  729. #if DONTEXPAND
  730.             bytepixels= linebuf + j+1;
  731. #else
  732.             bytepixels = expandbuf(linebuf + j+1, &buflen, pixelSize);
  733. #endif
  734.             for (k = 0; k < buflen; k++) {
  735.                     abyte= *bytepixels++;
  736. #ifdef WIN_MSWIN
  737.                     if (isBitmap) abyte= (byte) ~abyte;
  738. #endif
  739. #ifdef WIN_MOTIF
  740.                     if (isBitmap) abyte= XByteFlip[abyte];
  741. #endif
  742.                     *pbits++ = abyte;
  743.                     }
  744.             j += len * pkpixsize + 1;
  745.             }
  746.         }
  747. }
  748.  
  749.  
  750.  
  751. byte* DDrawPict::unpackbits( Nlm_RectPtr bounds, word rowBytes, short pixelSize, 
  752.                                                         ulong& unpackSize)
  753. {
  754.     enum { kFudgebuf = 300 };
  755.     byte *linebuf;
  756.     byte abyte, *bits, *pbits, *bitsend;
  757.     register long irow,j,k,l;
  758.     word  pixwidth;
  759.     short linelen, len;
  760.     byte* bytepixels;
  761.     short buflen, pkpixsize, rowsize;
  762.     Nlm_Boolean isBitmap = (pixelSize < 2);
  763.     
  764.   unpackSize= 0;
  765.     if (pixelSize <= 8) rowBytes &= 0x7fff;
  766.     pixwidth = bounds->right - bounds->left;
  767.  
  768.     pkpixsize = 1;
  769.     if (pixelSize == 16) {
  770.         pkpixsize = 2;
  771.         pixwidth *= 2;
  772.         }
  773.     else if (pixelSize == 32)
  774.         pixwidth *= 3;
  775.     
  776.     if (rowBytes == 0) rowBytes = pixwidth;
  777.  
  778. #if DONTEXPAND
  779.     /* dgg -- don't need 1byte/pixel, not expanding... */
  780.     rowsize = rowBytes;
  781. #else
  782.     rowsize = pixwidth;
  783.     if (rowBytes < 8) rowsize = 8 * rowBytes;    /* worst case expansion factor */
  784. #endif
  785.  
  786.     unpackSize= rowsize * (bounds->bottom - bounds->top);
  787.     bits = (byte*)Nlm_MemNew( (unpackSize + 8) * sizeof(byte) );
  788.     if (!bits) Nlm_Message(MSG_FATAL, "drawpict:no mem for packbits rectangle");
  789.         
  790.     linebuf = (byte*)Nlm_MemNew(rowBytes + kFudgebuf);
  791.     if (!linebuf) Nlm_Message(MSG_FATAL,"drawpict:can't allocate memory for line buffer");
  792.  
  793.     bitsend= bits + rowBytes * (bounds->bottom - bounds->top - 1);
  794.     if (rowBytes < 8) {
  795.         for (irow = 0; irow < bounds->bottom - bounds->top; irow++)
  796.             //unpackSmallLine(irow, linebuf, bits, bitsend, rowBytes, pixelSize);
  797. ///***********
  798.         {
  799.             buflen = rowBytes;
  800.             getbytes((char*) linebuf, buflen);
  801. #if DONTEXPAND
  802. #ifdef WIN_MSWIN
  803.             if (!isBitmap) pbits= bitsend - irow*rowBytes;
  804.             else
  805. #endif
  806.             pbits = bits + irow * rowBytes; // pixwidth; 
  807.             bytepixels= linebuf;
  808. #else
  809.             pbits = bits + irow * pixwidth;
  810.             bytepixels = expandbuf(linebuf, &buflen, pixelSize);
  811. #endif
  812.  
  813.             for (j = 0; j < buflen; j++) {
  814.                 abyte= *bytepixels++;
  815. #ifdef WIN_MSWIN
  816.                 if (isBitmap) abyte= (byte) ~abyte;
  817. #endif
  818. #ifdef WIN_MOTIF
  819.                 if (isBitmap) abyte= XByteFlip[abyte];
  820. #endif
  821.                  *pbits++ = abyte;
  822.                 }
  823.             }
  824. //****************/
  825.  
  826.         }
  827.         
  828.     else {
  829.         for (irow = 0; irow < bounds->bottom - bounds->top; irow++) 
  830.             //unpackBigLine(irow, linebuf, bits, bitsend, rowBytes, pixelSize, pkpixsize);
  831.  
  832.         {
  833. #if 1
  834. #ifdef WIN_MSWIN
  835.             if (!isBitmap) pbits= bitsend - irow*rowBytes;
  836.             else
  837. #endif
  838.             pbits = bits + irow * rowBytes;  
  839. #else
  840.             pbits = bits + irow * pixwidth;
  841. #endif
  842.  
  843.             if (rowBytes > 250 || pixelSize > 8)
  844.                 linelen = getWord();
  845.             else
  846.                 linelen = getByte();
  847.  
  848.             if (linelen >= kFudgebuf+rowBytes)   
  849.                 Nlm_Message(MSG_FATAL,"drawpict:linelen > rowbytes");
  850.      
  851.             getbytes((char*) linebuf, linelen);
  852.             
  853.             for (j = 0; j < linelen; ) {
  854.                 if (linebuf[j] & 0x80) {
  855.                     len = ((linebuf[j] ^ 255) & 255) + 2;
  856.                     buflen = pkpixsize;
  857. #if DONTEXPAND
  858.                     bytepixels= linebuf + j+1;
  859. #else
  860.                     bytepixels = expandbuf(linebuf + j+1, &buflen, pixelSize);
  861. #endif
  862.                     for (k = 0; k < len; k++) {
  863.                         for (l = 0; l < buflen; l++) {
  864.                             abyte= *bytepixels++;
  865. #ifdef WIN_MSWIN
  866.                             if (isBitmap) abyte= (byte) ~abyte;
  867. #endif
  868. #ifdef WIN_MOTIF
  869.                             if (isBitmap) abyte= XByteFlip[abyte];
  870. #endif
  871.                             *pbits++ = abyte;
  872.                             }
  873.                         bytepixels -= buflen;
  874.                         }
  875.                     j += 1 + pkpixsize;
  876.                     }
  877.                 else {
  878.                     len = (linebuf[j] & 255) + 1;
  879.                     buflen = len * pkpixsize;
  880. #if DONTEXPAND
  881.                     bytepixels= linebuf + j+1;
  882. #else
  883.                     bytepixels = expandbuf(linebuf + j+1, &buflen, pixelSize);
  884. #endif
  885.                     for (k = 0; k < buflen; k++) {
  886.                             abyte= *bytepixels++;
  887. #ifdef WIN_MSWIN
  888.                             if (isBitmap) abyte= (byte) ~abyte;
  889. #endif
  890. #ifdef WIN_MOTIF
  891.                             if (isBitmap) abyte= XByteFlip[abyte];
  892. #endif
  893.                             *pbits++ = abyte;
  894.                             }
  895.                     j += len * pkpixsize + 1;
  896.                     }
  897.                 }
  898.             }
  899. ///************************/
  900.  
  901.         }
  902.  
  903.     Nlm_MemFree(linebuf);
  904.     return bits;
  905. }
  906.  
  907.  
  908.  
  909.  
  910. void DDrawPict::read_pixmap(PIXMapPtr p, word* rowBytes)
  911. {
  912.     Nlm_RecT    arec;
  913.     if (rowBytes != NULL) *rowBytes = getWord();
  914.  
  915.     getRectAsis( &arec);
  916.     p->Bounds.left= arec.left;
  917.     p->Bounds.top= arec.top;
  918.     p->Bounds.right= arec.right;
  919.     p->Bounds.bottom= arec.bottom;
  920.     p->pmVersion = getWord();
  921.     p->packType = getWord();
  922.     p->packSize = getLong();
  923.     p->hRes = getLong();
  924.     p->vRes = getLong();
  925.     p->pixelType = getWord();
  926.     p->pixelSize = getWord();
  927.     p->cmpCount = getWord();
  928.     p->cmpSize = getWord();
  929.     p->planeBytes = getLong();
  930.     p->pmTable = getLong();
  931.     p->pmReserved = getLong();
  932.  
  933.     if (p->pixelType != 0)
  934.         Nlm_Message(MSG_FATAL,"drawpict: sorry, I only do chunky format");
  935.     if (p->cmpCount != 1)
  936.         Nlm_Message(MSG_FATAL,"drawpict: sorry, cmpCount != 1");
  937.     if (p->pixelSize != p->cmpSize)
  938.         Nlm_Message(MSG_FATAL,"drawpict: oops, pixelSize != cmpSize");
  939. }
  940.  
  941.  
  942. KolorTable DDrawPict::read_colour_table(void)
  943. {
  944.     longword ctSeed;
  945.     word ctFlags;
  946.     word ctSize;
  947.     word val;
  948.     long i;
  949.     /* RGBKolorPtr colour_table;*/
  950.     KolorTable    kolorTab;
  951.     KolorSpec*    kolors;
  952.     
  953.     kolorTab.ctSeed = ctSeed = getLong();
  954.     kolorTab.ctFlags = ctFlags =  getWord();
  955.     kolorTab.ctSize = ctSize = getWord();
  956.  
  957. #if 0
  958.     kolorTab.ctSeed = ctSeed= 1023; /* == minSeed in qd colormanager */
  959. #endif
  960.  
  961.     kolors = (KolorSpec*) Nlm_MemNew( sizeof(KolorSpec) * (ctSize + 1));
  962.     if (kolors == NULL)
  963.         Nlm_Message(MSG_FATAL,"drawpict: no memory for colors table");
  964.     kolorTab.ctTable= kolors;
  965.     
  966.     for (i = 0; i <= ctSize; i++) {
  967.         val = getWord();
  968.         if (ctFlags & 0x8000) val = i;
  969.         if (val > ctSize)
  970.             Nlm_Message(MSG_FATAL,"drawpict: pixel value greater than colour table size");
  971.         kolors[val].value= val;
  972.         kolors[val].rgb.red = getWord();
  973.         kolors[val].rgb.green = getWord();
  974.         kolors[val].rgb.blue = getWord();
  975.         }
  976.  
  977.     return kolorTab;
  978. }
  979.  
  980.  
  981. void DDrawPict::read_pattern(void)
  982. {
  983.     word         PatType;
  984.     word         rowBytes;
  985.     PIXMap     p;
  986.     byte*         bits;
  987.     KolorTable     ct;
  988.     Nlm_RecT    arec;
  989.     ulong    unpackSize;
  990.     
  991.     PatType = getWord();
  992.     switch (PatType) {
  993.     case 2:
  994.         skipbytes(8); /* old pattern data */
  995.         skipbytes(5); /* RGB for pattern */
  996.         break;
  997.     case 1:
  998.         skipbytes(8); /* old pattern data */
  999.         read_pixmap(&p, &rowBytes);
  1000.         ct = read_colour_table();
  1001.         arec.left= p.Bounds.left;
  1002.         arec.top= p.Bounds.top;
  1003.         arec.right= p.Bounds.right;
  1004.         arec.bottom= p.Bounds.bottom;
  1005.         bits = unpackbits(&arec, rowBytes, p.pixelSize, unpackSize);
  1006.         Nlm_MemFree(bits);
  1007.         Nlm_MemFree(ct.ctTable);
  1008.         break;
  1009.     default:
  1010.         Nlm_Message(MSG_FATAL,"drawpict: unknown pattern type in read_pattern");
  1011.     }
  1012. }
  1013.  
  1014.  
  1015.  
  1016.  
  1017. #ifdef WIN_MOTIF
  1018. // static
  1019. Local void FindXColor( Display *dsp, Colormap cmap, XColor* colr)
  1020. {
  1021.      long  i, match, cindx, numCells;
  1022.   long  rd, gd, bd, dist, mindist;
  1023.   static XColor defColrs[256];
  1024.   static Boolean haveColrs= false;
  1025.  
  1026.               // must leave some of 256 colors for other apps
  1027.               // damn X for its messy color handling !
  1028.   if (gNAllocatedColors < 248) 
  1029.       match= XAllocColor( dsp, cmap, colr);
  1030.   else
  1031.       match= 0;
  1032.       
  1033.   if (match == 0) {
  1034.     numCells= DisplayCells( dsp, DefaultScreen(dsp));
  1035.     if (!haveColrs) {
  1036.       for (i=0; i<numCells; i++) defColrs[i].pixel= i;
  1037.       XQueryColors( dsp, cmap, defColrs, numCells);
  1038.       haveColrs= true;
  1039.       }
  1040.     mindist= 196608; // 256 * 256 * 3  
  1041.     //mindist= 768; // 256 * 3 */
  1042.     cindx= colr->pixel;
  1043.     for (i= 0; i<numCells; i++) {
  1044.       rd= (defColrs[i].red >> 8) - (colr->red >> 8);
  1045.       gd= (defColrs[i].green >> 8) - (colr->green >> 8);
  1046.       bd= (defColrs[i].blue >> 8) - (colr->blue >> 8);
  1047.       dist= (rd * rd) + (gd * gd) + (bd * bd);
  1048.       //dist= abs(rd) + abs(gd) + abs(bd);
  1049.       if (dist < mindist) {
  1050.          mindist= dist;
  1051.          cindx= defColrs[i].pixel;
  1052.          if (dist==0) break;
  1053.          }
  1054.       }
  1055.     colr->pixel= cindx;
  1056.     colr->red  = defColrs[cindx].red;
  1057.     colr->green= defColrs[cindx].green;
  1058.     colr->blue = defColrs[cindx].blue;
  1059.     }
  1060.   else {
  1061.     if (gNAllocatedColors==0) {
  1062.         for (i=0; i<256; i++) gAllocatedColors[i]= 0;
  1063.         }
  1064.     gAllocatedColors[colr->pixel]++;
  1065.     if (gAllocatedColors[colr->pixel] == 1) {
  1066.         gNAllocatedColors++;
  1067.         haveColrs= 0;
  1068.         }
  1069.     }
  1070. }
  1071. #endif
  1072.  
  1073.  
  1074. // static
  1075. void DDrawPict::Pixmap2Xcolors( KolorTable& kolorTab, unsigned char* bits, ulong bitsize,
  1076.                                                                     Nlm_Boolean returnXtabInBits)
  1077. {
  1078. #ifdef WIN_MOTIF
  1079.     if (!(kolorTab.ctFlags & kXColorTableFlag)) {
  1080.         byte         xtab[256], ival, abyte;
  1081.       short     ic;
  1082.       XColor    xcol;
  1083.       Display * display = Nlm_currentXDisplay;
  1084.       short   screenNum= DefaultScreen( display);
  1085.         Visual     * visual= DefaultVisual( display, screenNum);
  1086.         Colormap colormap = DefaultColormap( display, screenNum);    
  1087.     
  1088.         xcol.flags= DoRed | DoGreen | DoBlue;
  1089.         for (ic=0; ic <= kolorTab.ctSize; ic++) {
  1090.             ival= (byte) kolorTab.ctTable[ic].value;
  1091.             xcol.red=   kolorTab.ctTable[ic].rgb.red;
  1092.             xcol.green= kolorTab.ctTable[ic].rgb.green;
  1093.             xcol.blue=  kolorTab.ctTable[ic].rgb.blue;
  1094.             FindXColor( display, colormap, &xcol);
  1095.             xtab[ival]= (byte) xcol.pixel;
  1096.             }
  1097.         kolorTab.ctFlags |= kXColorTableFlag;
  1098.         
  1099.         if (returnXtabInBits && bits && bitsize >= 256) {
  1100.             for (ic= 0; ic < 256; ic++) bits[ic]= xtab[ic];
  1101.             }
  1102.         else if (bits) {
  1103.             register byte* pbits= bits;
  1104.             for (long ib= 0; ib<bitsize; ib++) { 
  1105.                 //abyte= XByteFlip[*pbits]; //must use unflipped vals, fix now in unpackbits
  1106.                 *pbits= (byte) xtab[*pbits];
  1107.                 pbits++;
  1108.                 }
  1109.             }
  1110.         }
  1111. #endif
  1112. }
  1113.  
  1114.  
  1115.  
  1116.  
  1117. void DDrawPict::drawPixmap( short version, word rowBytes, short isregion )
  1118. {
  1119.     word         mode;
  1120.     PIXMap     p;
  1121.     word         pixwidth;
  1122.     byte        * bits;
  1123.     KolorTable    kolorTab;
  1124.     Nlm_RecT    arec, sourcerec, destrec;
  1125.     ulong        unpackSize;
  1126.     
  1127.     read_pixmap(&p, NULL);
  1128.     pixwidth = p.Bounds.right - p.Bounds.left;
  1129.     kolorTab = read_colour_table();
  1130.  
  1131.     getRectAsis(&sourcerec);
  1132.     getRectLocal( &destrec);
  1133.     mode = getWord();
  1134.     if (isregion) skipPolyOrRegion();
  1135.  
  1136.     arec.left= p.Bounds.left;
  1137.     arec.top= p.Bounds.top;
  1138.     arec.right= p.Bounds.right;
  1139.     arec.bottom= p.Bounds.bottom;
  1140.     bits = unpackbits( &arec, rowBytes, p.pixelSize, unpackSize);
  1141.     if (!bits) return;
  1142.  
  1143. #ifdef WIN_MAC
  1144.     {
  1145.     Nlm_RectTool   srcRect, dstRect;
  1146.     PixMap        srcBits;
  1147.     GrafPtr       port;
  1148.     CTabHandle    cthand;
  1149.     long                ic, ctsize;
  1150.     //PaletteHandle oldph,ph;
  1151.     
  1152.     cthand= NULL;
  1153.     ctsize = (kolorTab.ctSize + 1) * sizeof(ColorSpec);
  1154.     cthand= (CTabHandle) NewHandle(sizeof(ColorTable) + ctsize);
  1155.     if (cthand) {
  1156.         (**cthand).ctSeed = kolorTab.ctSeed;
  1157.         (**cthand).ctFlags= kolorTab.ctFlags;
  1158.         (**cthand).ctSize = kolorTab.ctSize;
  1159.         /* MemCpy( &(**cthand).ctTable, &(kolorTab.ctTable), ctsize); */
  1160.         for (ic=0; ic <= kolorTab.ctSize; ic++) {
  1161.             (**cthand).ctTable[ic].value= kolorTab.ctTable[ic].value;
  1162.             (**cthand).ctTable[ic].rgb.red= kolorTab.ctTable[ic].rgb.red;
  1163.             (**cthand).ctTable[ic].rgb.green= kolorTab.ctTable[ic].rgb.green;
  1164.             (**cthand).ctTable[ic].rgb.blue= kolorTab.ctTable[ic].rgb.blue;
  1165.             }
  1166.         }
  1167.         
  1168.     Nlm_RecTToRectTool( &sourcerec, &srcRect);
  1169.     Nlm_RecTToRectTool( &destrec, &dstRect);
  1170.  
  1171.     srcBits.pmVersion= p.pmVersion;
  1172.     srcBits.packType= p.packType;
  1173.     srcBits.packSize= p.packSize;
  1174.     srcBits.hRes= p.hRes;
  1175.     srcBits.vRes= p.vRes;
  1176.     srcBits.pixelType= p.pixelType;
  1177.     srcBits.pixelSize= p.pixelSize;
  1178.     srcBits.cmpCount= p.cmpCount;
  1179.     srcBits.cmpSize= p.cmpSize;
  1180.     srcBits.planeBytes= p.planeBytes;
  1181.     srcBits.pmTable= cthand; 
  1182.     srcBits.pmReserved= p.pmReserved;
  1183.     
  1184.     srcBits.bounds.left= p.Bounds.left;
  1185.     srcBits.bounds.top = p.Bounds.top;
  1186.     srcBits.bounds.right= p.Bounds.right;
  1187.     srcBits.bounds.bottom= p.Bounds.bottom;
  1188.     srcBits.baseAddr = (Ptr) bits;
  1189.     srcBits.rowBytes = rowBytes;  
  1190.     
  1191.     GetPort (&port);
  1192.  
  1193.     CopyBits( (BitMap*) &srcBits, &port->portBits, &srcRect, &dstRect, mode, NULL);
  1194.     if (cthand) DisposHandle((Handle)cthand);
  1195.     Nlm_MemFree( bits);
  1196.  
  1197.     }
  1198. #endif
  1199.  
  1200.  
  1201. #ifdef WIN_MSWIN
  1202.   {
  1203.     HBITMAP       hBitmap, hOldBitmap;
  1204.     HDC           hMemoryDC, hDC;
  1205.     Nlm_Int4      dbisize, wmode;
  1206.     Nlm_Int2      ic, dwidth, dheight, swidth, sheight, rows, depth;
  1207.     BITMAPINFO        *dbi;
  1208.  
  1209.       depth= p.pixelSize; /* ?! check display depth */
  1210.         switch (mode) {
  1211.             /* translate apple to x modes */
  1212.             case 0: case 8: wmode = SRCCOPY; break;  /* srcCopy */
  1213.             case 1: case 9: wmode = SRCAND; break; /* srcOr */
  1214.             case 2: case 10: wmode = 0x00990066; break;   /* srcXor */
  1215.             case 3: case 11: wmode = MERGEPAINT; break;   /* srcBic */
  1216.             default:     wmode = SRCCOPY; /*WHITENESS;*/ break;
  1217.             }
  1218.  
  1219.     hDC= GetDC( Nlm_currentHWnd); //Nlm_currentHDC; /*GetDC( Nlm_currentHWnd); */
  1220.     if (bits && hDC) {
  1221.             dwidth= destrec.right - destrec.left;
  1222.             dheight= destrec.bottom - destrec.top;
  1223.             swidth= p.Bounds.right - p.Bounds.left;
  1224.             sheight= p.Bounds.bottom - p.Bounds.top;
  1225.  
  1226. #if 1
  1227.             dbisize= sizeof(BITMAPINFOHEADER) + (kolorTab.ctSize+1) * sizeof(RGBQUAD);
  1228.             dbi= (BITMAPINFO*) MemGet( dbisize, TRUE);
  1229.             dbi->bmiHeader.biSize= sizeof(BITMAPINFOHEADER); /* dbisize; */
  1230.             dbi->bmiHeader.biWidth= swidth;
  1231.             dbi->bmiHeader.biHeight= sheight;
  1232.             dbi->bmiHeader.biPlanes= 1; /*p.planeBytes; */
  1233.             dbi->bmiHeader.biBitCount=  p.pixelSize;
  1234.             dbi->bmiHeader.biCompression= 0;
  1235.             dbi->bmiHeader.biSizeImage= 0;
  1236.             dbi->bmiHeader.biClrUsed= kolorTab.ctSize + 1; 
  1237.             for (ic=0; ic <= kolorTab.ctSize; ic++) {
  1238.                 /* !??! need to remap kolorTab if (table[ic].value != ic) !!! */
  1239.                 dbi->bmiColors[ic].rgbRed= (byte) (kolorTab.ctTable[ic].rgb.red >>8);
  1240.                 dbi->bmiColors[ic].rgbGreen= (byte) (kolorTab.ctTable[ic].rgb.green >>8);
  1241.                 dbi->bmiColors[ic].rgbBlue= (byte) (kolorTab.ctTable[ic].rgb.blue >>8);
  1242.                 }
  1243.  
  1244. #if 1
  1245.             hMemoryDC = CreateCompatibleDC (hDC);
  1246. #if 0
  1247.             // ?? is the 1st param == hDC or hMemoryDC
  1248.             hBitmap= CreateDIBitmap( hDC, &(dbi->bmiHeader), 0, NULL, NULL, 0);
  1249.             if (hBitmap) {
  1250.                  SetDIBits( hDC, hBitmap, 0, sheight, bits, dbi, DIB_RGB_COLORS);
  1251.                 }
  1252. #else
  1253.             hBitmap= CreateDIBitmap( hDC, &(dbi->bmiHeader), CBM_INIT, bits, dbi, DIB_RGB_COLORS);
  1254. #endif
  1255.  
  1256.             hOldBitmap = (HBITMAP) SelectObject (hMemoryDC, hBitmap);
  1257.             if (hOldBitmap != NULL) {
  1258.                 /*SetViewportOrg( hDC, 0, destrec.bottom);*/
  1259.                 BitBlt ( hDC, destrec.left, destrec.top, swidth, sheight,
  1260.                                 hMemoryDC, 0, 0, wmode);
  1261.               /*SetViewportOrg( hDC, 0, 0); */ 
  1262.                 SelectObject (hMemoryDC, hOldBitmap);
  1263.                 }
  1264.             DeleteDC (hMemoryDC);
  1265.             DeleteObject (hBitmap);
  1266.             /* ReleaseDC( Nlm_currentHWnd, hDC); */
  1267. #else
  1268.             /* hDC= CreateCompatibleDC(Nlm_currentHDC);*/ /*?? or BeginPaint()... */
  1269.  
  1270.             /* SetViewportOrg( hDC, 0, -destrec.bottom); */
  1271.             SetDIBitsToDevice( hDC, destrec.left, destrec.top, swidth, sheight,
  1272.                     0, 0, swidth, sheight, (LPSTR) bits, (LPBITMAPINFO) dbi, DIB_RGB_COLORS
  1273.                     ); /* , wmode); */
  1274.             /* SetDIBitsToDevice StretchDIBits */
  1275.             /* SetViewportOrg( hDC, 0, 0);   */
  1276.  
  1277.             ReleaseDC( Nlm_currentHWnd, hDC);
  1278.             /*DeleteDC (hMemoryDC); */
  1279. #endif
  1280.  
  1281.             MemFree(dbi);
  1282. #else
  1283.             hBitmap = CreateBitmap ( swidth, sheight, 1, depth, (LPSTR) bits);
  1284.             hMemoryDC = CreateCompatibleDC (Nlm_currentHDC);
  1285.       hOldBitmap = SelectObject (hMemoryDC, hBitmap);
  1286.       if (hOldBitmap != NULL) {
  1287.                 BitBlt (Nlm_currentHDC, destrec.left, destrec.top, swidth, sheight,
  1288.                                 hMemoryDC, 0, 0, wmode);
  1289.                 SelectObject (hMemoryDC, hOldBitmap);
  1290.                 }
  1291.             DeleteDC (hMemoryDC);
  1292.             DeleteObject (hBitmap);
  1293. #endif
  1294.             }
  1295.     }
  1296.     Nlm_MemFree( bits);
  1297. #endif
  1298.  
  1299.  
  1300. #ifdef WIN_MOTIF
  1301.     {
  1302.     short   depth, width, height, xmode;
  1303.     XImage    *ximage;
  1304.     Pixmap  pixmap;
  1305.     GC             drawGC;
  1306.   short        ic, flag;
  1307.   XColor    xcol;
  1308.   byte  * pbits = bits;
  1309.   Display *display = Nlm_currentXDisplay;
  1310.   short   screenNum= DefaultScreen(display);
  1311.     Visual * visual= DefaultVisual( display, screenNum);
  1312.     Colormap colormap = DefaultColormap( display, screenNum);    
  1313.  
  1314.   width  = destrec.right - destrec.left;
  1315.   height = destrec.bottom - destrec.top;
  1316.   depth  = p.pixelSize; /* ?! check display depth */
  1317.   switch (mode) {
  1318.         /* translate apple to x modes */
  1319.       default: xmode= COPY_MODE;
  1320.       }
  1321.  
  1322.  
  1323.     Pixmap2Xcolors( kolorTab, bits, unpackSize, false);
  1324. #if 0
  1325.     {
  1326.     byte xtab[256], ival, abyte;
  1327.     xcol.flags= DoRed | DoGreen | DoBlue;
  1328.     for (ic=0; ic <= kolorTab.ctSize; ic++) {
  1329.         ival= (byte) kolorTab.ctTable[ic].value;
  1330.         xcol.red=   kolorTab.ctTable[ic].rgb.red;
  1331.         xcol.green= kolorTab.ctTable[ic].rgb.green;
  1332.         xcol.blue=  kolorTab.ctTable[ic].rgb.blue;
  1333.         FindXColor( display, colormap, &xcol);
  1334.         xtab[ival]= (byte) xcol.pixel;
  1335.         }
  1336.         
  1337.     long isize= unpackSize; //width * height;
  1338.     pbits= bits;
  1339.     for (long ib= 0; ib<isize; ib++) { 
  1340.         //abyte= XByteFlip[*pbits]; // !! YES !! ?? do we need to unflip this for pixmap !? (not for bitmap)
  1341.         *pbits= (byte) xtab[*pbits];
  1342.         pbits++;
  1343.         }
  1344.     pbits= bits;
  1345.     }
  1346. #endif
  1347.  
  1348. #if 0
  1349.     if (!gPixColorsDone &&  p.pixelSize <= 8)  {
  1350.      // this jazz is a hack good only for 8bit pixels (or less??) !!
  1351.    byte xtab[256], ival;
  1352.    gPixColorsDone= true;
  1353.  
  1354. /* need to do something about color table -- in GC ?? */
  1355.     xcol.flags= DoRed | DoGreen | DoBlue;
  1356.         for (ic=0; ic <= kolorTab.ctSize; ic++) {
  1357.         ival= kolorTab.ctTable[ic].value;
  1358.                 xcol.red=   kolorTab.ctTable[ic].rgb.red;
  1359.                 xcol.green= kolorTab.ctTable[ic].rgb.green;
  1360.                 xcol.blue=  kolorTab.ctTable[ic].rgb.blue;
  1361. // damn xwin won't let me use colortab mapping !? stupid get
  1362.                  //XStoreColor( display, colormap, &xcol);
  1363.         XAllocColor( display, colormap, &xcol);
  1364.         xtab[ival]= xcol.pixel;
  1365.        }
  1366.  
  1367. // damn so we do it the hard way and change all pixmap bits values !
  1368. // Double Damn -- can't do this on each redraw !! only once !!!
  1369.    byte cval;
  1370.    for (long ib= 0; ib<unpackSize; ib++) {
  1371.            cval= (byte) bits[ib];
  1372.       bits[ib]= xtab[cval];
  1373.       }
  1374. }
  1375. #endif
  1376.  
  1377.         short rowpad = 8; // 8,16 or 32 bits.  Use 16 if rowbytes == 1 + width !? for short pad
  1378.     short bitsoffset= 0;
  1379.     ximage = XCreateImage ( display, visual,
  1380.                                 depth, ZPixmap, bitsoffset, (char *) pbits, 
  1381.                         width, height, rowpad, rowBytes & 0x7fff);
  1382.         if (ximage) {
  1383.             pixmap = XCreatePixmap(display, Nlm_currentXWindow, width, height, depth);
  1384.             drawGC = XCreateGC(display, Nlm_currentXWindow, 0, NULL); 
  1385.             XSetFunction(display, drawGC, GXcopy); 
  1386.             XPutImage(display, pixmap, drawGC, ximage, 0,0, 0,0, width, height);
  1387.             XCopyArea(display, pixmap, Nlm_currentXWindow, drawGC, 0, 0, 
  1388.                     width, height, destrec.left - Nlm_XOffset, destrec.top - Nlm_YOffset);
  1389.             XFreeGC(display, drawGC); 
  1390.       XDestroyImage (ximage);
  1391.       XFreePixmap (display, pixmap);
  1392.             }
  1393.     }
  1394.  
  1395. #endif
  1396.  
  1397.     Nlm_MemFree( bits);
  1398.     Nlm_MemFree( kolorTab.ctTable);
  1399. }
  1400.  
  1401.  
  1402.  
  1403. void DDrawPict::drawPixmapOp9A( short version )
  1404. {
  1405.     word         mode;
  1406.     PIXMap     p;
  1407.     word         pixwidth;
  1408.     byte    * bits;
  1409.     //KolorTable kolorTab;
  1410.     Nlm_RecT     arec, sourcerec, destrec;
  1411.     ulong        unpackSize;
  1412.     
  1413.     skipbytes(4);
  1414.     p.pmVersion= getWord();    /* version */
  1415.     /* read_pixmap(&p, NULL); << not quite same for op9a */
  1416.     getRectAsis( &arec);
  1417.     p.Bounds.left= arec.left;
  1418.     p.Bounds.top= arec.top;
  1419.     p.Bounds.right= arec.right;
  1420.     p.Bounds.bottom= arec.bottom;
  1421.     /* p.pmVersion = getWord(); */
  1422.     p.packType = getWord();
  1423.     p.packSize = getLong();
  1424.     p.hRes = getLong();
  1425.     p.vRes = getLong();
  1426.     p.pixelType = getWord();
  1427.     p.pixelSize = getWord();
  1428.     p.pixelSize = getWord(); /* ?? is this right, two words ? */
  1429.     p.cmpCount = getWord();
  1430.     p.cmpSize = getWord();
  1431.     p.planeBytes = getLong();
  1432.     p.pmTable = getLong();
  1433.     p.pmReserved = getLong();
  1434.  
  1435.     pixwidth = p.Bounds.right - p.Bounds.left;
  1436.     /* kolorTab = read_colour_table(); << !! no color table in this op */
  1437.     
  1438.     getRectAsis( &sourcerec);
  1439.     getRectLocal( &destrec);
  1440.     mode = getWord();
  1441.  
  1442.     arec.left= p.Bounds.left;
  1443.     arec.top= p.Bounds.top;
  1444.     arec.right= p.Bounds.right;
  1445.     arec.bottom= p.Bounds.bottom;
  1446.     bits = unpackbits( &arec, 0, p.pixelSize, unpackSize);
  1447.     if (!bits) return;
  1448.  
  1449. #ifdef WIN_MAC
  1450.     {
  1451.   Nlm_RectTool   srcRect, dstRect;
  1452.   PixMap    srcBits;
  1453.   GrafPtr   port;
  1454.     CTabPtr        ctptr;
  1455.     
  1456.     Nlm_RecTToRectTool( &sourcerec, &srcRect);
  1457.     Nlm_RecTToRectTool( &destrec, &dstRect);
  1458.     ctptr= NULL; /* = (CTabPtr) &kolorTab; */
  1459.     
  1460.     /* ?? srcBits= *((PixMapPtr) &p); */
  1461.     srcBits.pmVersion= p.pmVersion;
  1462.     srcBits.packType= p.packType;
  1463.     srcBits.packSize= p.packSize;
  1464.     srcBits.hRes= p.hRes;
  1465.     srcBits.vRes= p.vRes;
  1466.     srcBits.pixelType= p.pixelType;
  1467.     srcBits.pixelSize= p.pixelSize;
  1468.     srcBits.cmpCount= p.cmpCount;
  1469.     srcBits.cmpSize= p.cmpSize;
  1470.     srcBits.planeBytes= p.planeBytes;
  1471.     srcBits.pmTable= &ctptr; /* p.pmTable;*/
  1472.     srcBits.pmReserved= p.pmReserved;
  1473.     
  1474.     srcBits.bounds.left= p.Bounds.left;
  1475.     srcBits.bounds.top = p.Bounds.top;
  1476.     srcBits.bounds.right= p.Bounds.right;
  1477.     srcBits.bounds.bottom= p.Bounds.bottom;
  1478.     srcBits.baseAddr = (Ptr) bits;
  1479.     /* srcBits.rowBytes = rowBytes;  */
  1480.     srcBits.rowBytes = (p.Bounds.right - p.Bounds.left - 1) / 8 + 1;
  1481.     
  1482.     GetPort (&port);
  1483.     CopyBits( (BitMap*) &srcBits, &port->portBits, &srcRect, &dstRect, mode, NULL);
  1484.     }
  1485. #endif
  1486. #ifdef WIN_MSWIN
  1487. #endif
  1488. #ifdef WIN_MOTIF
  1489. #endif
  1490.  
  1491.     Nlm_MemFree( bits);
  1492.     /* Nlm_MemFree( kolorTab.ctTable); */
  1493. }
  1494.  
  1495.  
  1496.  
  1497.  
  1498. void DDrawPict::drawBitmap(short version, short rowBytes, Nlm_Boolean isregion)
  1499. {
  1500.     Nlm_RecT bounds, sourcerec, destrec;
  1501.     word mode;
  1502.     byte *bits;
  1503.     ulong    unpackSize;
  1504.     
  1505.     getRectAsis(&bounds);
  1506.     getRectAsis(&sourcerec);
  1507.     getRectLocal( &destrec);
  1508.     mode = getWord();
  1509.     if (isregion) skipPolyOrRegion();
  1510.  
  1511.     bits = unpackbits( &bounds, rowBytes, 1, unpackSize);
  1512.     if (!bits) return;
  1513.     
  1514. #ifdef WIN_MAC
  1515.     {
  1516.   Nlm_RectTool   boundsRect, srcRect, dstRect;
  1517.   BitMap    srcBits;
  1518.   GrafPtr   port;
  1519.  
  1520.     Nlm_RecTToRectTool( &bounds, &boundsRect);
  1521.     Nlm_RecTToRectTool( &sourcerec, &srcRect);
  1522.     Nlm_RecTToRectTool( &destrec, &dstRect);
  1523.     srcBits.baseAddr = (Ptr) bits;
  1524.     srcBits.rowBytes = rowBytes;  
  1525.     srcBits.bounds = boundsRect;
  1526.     GetPort (&port);
  1527.     /* mode= srcCopy; /* testing... */
  1528.     CopyBits( &srcBits, &port->portBits, &srcRect, &dstRect, mode, NULL);
  1529.     }
  1530. #endif
  1531. #ifdef WIN_MSWIN
  1532.     /* Nlm_CopyBits( &destrec, bits); /* this is a hack -- should do directly */
  1533.   {
  1534.     HBITMAP       hBitmap, hOldBitmap;
  1535.     HDC           hMemoryDC;
  1536.     Nlm_Int4      wmode;
  1537.     Nlm_Int2      rop2, width, height, rows, depth;
  1538.  
  1539.         depth= 1; /* ?! check display depth */
  1540.         switch (mode) {
  1541.             /* translate apple to x modes */
  1542.             case 0: case 8: wmode = SRCCOPY; break;  /* srcCopy */
  1543.             case 1: case 9: wmode = SRCAND; break; /* srcOr */
  1544.             case 2: case 10: wmode = 0x00990066; break;   /* srcXor */
  1545.             case 3: case 11: wmode = MERGEPAINT; break;   /* srcBic */
  1546.             default:     wmode = SRCCOPY; /*WHITENESS;*/ break;
  1547.             }
  1548.  
  1549.     if (bits && Nlm_currentHDC) {
  1550.             width= destrec.right - destrec.left;
  1551.             height= destrec.bottom - destrec.top;
  1552.  
  1553.             hBitmap = CreateBitmap ( width, height, 1, depth, (LPSTR) bits);
  1554.             hMemoryDC = CreateCompatibleDC (Nlm_currentHDC);
  1555.             hOldBitmap = (HBITMAP) SelectObject (hMemoryDC, hBitmap);
  1556.       if (hOldBitmap != NULL) {
  1557.                 BitBlt (Nlm_currentHDC, destrec.left, destrec.top, width, height,
  1558.                                 hMemoryDC, 0, 0, wmode);
  1559.                 SelectObject (hMemoryDC, hOldBitmap);
  1560.                 }
  1561.             DeleteDC (hMemoryDC);
  1562.       DeleteObject (hBitmap);
  1563.             }
  1564.     }
  1565.  
  1566. #endif
  1567. #ifdef WIN_MOTIF
  1568.     /* Nlm_CopyBits( &destrec, bits); /* this is a hack -- should do directly */
  1569.  
  1570.     {
  1571.     short  width, height, xmode;
  1572.       Pixmap        pixmap;
  1573.  
  1574.         switch (mode) {
  1575.             /* translate apple to x modes */
  1576.             default: xmode= COPY_MODE;
  1577.             }
  1578.  
  1579.       width = destrec.right - destrec.left;
  1580.       height = destrec.bottom - destrec.top;
  1581.       pixmap = XCreateBitmapFromData (Nlm_currentXDisplay, Nlm_currentXWindow,
  1582.                                       (char *) bits, width, height);
  1583.       if (xmode != MERGE_MODE) {
  1584.         XCopyPlane (Nlm_currentXDisplay, pixmap, Nlm_currentXWindow,
  1585.                     Nlm_currentXGC, 0, 0, width, height,
  1586.                     destrec.left - Nlm_XOffset, destrec.top - Nlm_YOffset, 1);
  1587.           } 
  1588.             else {
  1589.         XSetClipOrigin (Nlm_currentXDisplay, Nlm_currentXGC,
  1590.                         destrec.left - Nlm_XOffset, destrec.top - Nlm_YOffset);
  1591.         XSetClipMask (Nlm_currentXDisplay, Nlm_currentXGC, pixmap);
  1592.         XSetFunction (Nlm_currentXDisplay, Nlm_currentXGC, GXcopy);
  1593.         XCopyPlane (Nlm_currentXDisplay, pixmap, Nlm_currentXWindow,
  1594.                     Nlm_currentXGC, 0, 0, width, height,
  1595.                     destrec.left - Nlm_XOffset, destrec.top - Nlm_YOffset, 1);
  1596.         XSetFunction (Nlm_currentXDisplay, Nlm_currentXGC, GXand);
  1597.         XSetClipOrigin (Nlm_currentXDisplay, Nlm_currentXGC, 0, 0);
  1598.         if (Nlm_clpRgn != NULL) {
  1599.           XSetRegion (Nlm_currentXDisplay, Nlm_currentXGC, (Nlm_RgnTool) Nlm_clpRgn);
  1600.         } else {
  1601.           XSetClipMask (Nlm_currentXDisplay, Nlm_currentXGC, None);
  1602.         }
  1603.       }
  1604.       XFreePixmap (Nlm_currentXDisplay, pixmap);
  1605.     }
  1606.  
  1607. #endif
  1608.  
  1609.     Nlm_MemFree( bits);
  1610. }
  1611.  
  1612.  
  1613.  
  1614.  
  1615. enum fontStyles {
  1616.     kFontBold = 1,
  1617.     kFontItalic = 2,
  1618.     kFontUline = 4,
  1619.     kFontOutline = 8,
  1620.     kFontShadow = 16,
  1621.     kFontCondense = 32,
  1622.     kFontExtend = 64
  1623.     };
  1624.  
  1625.  
  1626.  
  1627. void DDrawPict::InstallFont()
  1628. {
  1629.     fFont= Nlm_GetFont(fFontname, fFontsize, fFontstyle & kFontBold,
  1630.             fFontstyle & kFontItalic, fFontstyle & kFontUline, fFontfamily);
  1631.     Nlm_SelectFont( fFont);    
  1632.     fNeedInstallFont= FALSE;        
  1633. }
  1634.  
  1635. void DDrawPict::SetFont(word fontnum)
  1636. {
  1637.     short i;
  1638.     if (fontnum == fLastFontnum) {
  1639.         fFontname= fLastFontname;
  1640.         fNeedInstallFont= TRUE;    
  1641.         fLastFontnum = -1; /* clear it after 1 use ? */    
  1642.         return;
  1643.         }        
  1644.     else for ( i=0; QuickDrawFont[i].value>=0; i++) {
  1645.         if (fontnum == QuickDrawFont[i].value) {
  1646.             fFontname= QuickDrawFont[i].name;
  1647.             fNeedInstallFont= TRUE;        
  1648.             return;
  1649.             }
  1650.         }
  1651. }
  1652.  
  1653. void DDrawPict::SetFontStyle(byte fstyle)
  1654. {
  1655.     fFontstyle= fstyle;
  1656.     fNeedInstallFont= TRUE;        
  1657. }
  1658.  
  1659. void DDrawPict::SetFontSize(word fsize)
  1660. {
  1661.     fFontsize= fsize;
  1662.     fNeedInstallFont= TRUE;        
  1663. }
  1664.  
  1665.  
  1666.  
  1667.  
  1668. void DDrawPict::getAArc(Nlm_RectPtr arec, Nlm_PointPtr pt, Nlm_PointPtr pt1)   
  1669. { 
  1670.     /* need some dang trigonometry here... */
  1671.     /* ?? just stuff a 45o angle for now ?? */
  1672.     short                arcStart, arcEnd;
  1673.     arcStart = getWord(); 
  1674.     arcEnd   = getWord();  
  1675.     pt->x = (arec->left + arec->right) >> 1; 
  1676.     pt->y = arec->top;  
  1677.     pt1->x= arec->right; 
  1678.     pt1->y= (arec->top + arec->bottom) >> 1; 
  1679. }
  1680.  
  1681. void DDrawPict::getAPoly(Nlm_RectPtr polybox, short* polycount, Nlm_PointPtr* thePoly) 
  1682. { 
  1683.     short                 sizepoly,    npoly, ip;
  1684.     Nlm_PoinT          polypt;
  1685.     Nlm_PointPtr     apoly;
  1686.     
  1687.     apoly= *thePoly;
  1688.     sizepoly= getWord(); 
  1689.     getRectLocal( polybox); 
  1690.     npoly = (sizepoly - 10) >> 2;   
  1691.     if (!apoly) apoly= (Nlm_PoinT*) Nlm_MemNew( npoly * sizeof(Nlm_PoinT));  
  1692.     else apoly=  (Nlm_PoinT*) Nlm_MemMore( apoly, npoly * sizeof(Nlm_PoinT)); 
  1693.     if (apoly) for (ip= 0; ip<npoly; ip++) {  
  1694.         getPointLocal( &polypt);  
  1695.         apoly[ip]= polypt;  
  1696.         } 
  1697.     *thePoly= apoly;
  1698.     *polycount = npoly;
  1699.         /* debug TESTING... */
  1700.     /* *polycount= 0; */
  1701. }
  1702.      
  1703.      
  1704. void DDrawPict::getARgn(Nlm_RectPtr rgnbox, Nlm_RegioN* theRgn, Nlm_Boolean forclip)
  1705. { 
  1706.   /* ! each win system has (?) own region format !! need to translate mac to others ! */
  1707.   /* just skip for now ! */
  1708.     short rgnsize;
  1709.     Nlm_RegioN    argn;
  1710.     
  1711.     argn= *theRgn;
  1712.     rgnsize= getWord(); 
  1713.     getRectLocal( rgnbox);
  1714.     
  1715.         /* this fix mainly for clip regions -- make sure it falls inside fPicRect */
  1716.     if (forclip) {
  1717.         if (rgnbox->left < fPicRect.left) rgnbox->left= fPicRect.left;
  1718.         if (rgnbox->top < fPicRect.top) rgnbox->top= fPicRect.top;
  1719.         if (rgnbox->right > fPicRect.right) rgnbox->right= fPicRect.right;
  1720.         if (rgnbox->bottom > fPicRect.bottom) rgnbox->bottom= fPicRect.bottom;
  1721.         }
  1722.     
  1723.     if (!argn) argn= Nlm_CreateRgn(); 
  1724.     else Nlm_ClearRgn( argn);  
  1725.     Nlm_LoadRectRgn( argn, rgnbox->left, rgnbox->top, rgnbox->right, rgnbox->bottom);  
  1726.     skipbytes( rgnsize - 10);  /* skip rgn data */
  1727.     *theRgn= argn;
  1728. }
  1729.  
  1730.  
  1731.  
  1732. void DDrawPict::getForeColor()
  1733. {
  1734.     switch (getLong()) {
  1735.         case 33: Nlm_Black(); break;
  1736.         case 30: Nlm_White(); break;
  1737.         case 205: Nlm_Red(); break;
  1738.         case 341: Nlm_Green(); break;
  1739.         case 409: Nlm_Blue(); break;
  1740.         case 273: Nlm_Cyan(); break;
  1741.         case 137: Nlm_Magenta(); break;
  1742.         case 69: Nlm_Yellow(); break;
  1743.         }
  1744. }
  1745.  
  1746.  
  1747. void DDrawPict::getBackColor()
  1748. {
  1749.     switch (getLong()) {
  1750.         case 33: Nlm_SelectBackColor(0,0,0); break;
  1751.         case 30: Nlm_SelectBackColor(255,255,255); break;
  1752.         case 205: Nlm_SelectBackColor(255,0,0); break;
  1753.         case 341: Nlm_SelectBackColor(0,255,0); break;
  1754.         case 409: Nlm_SelectBackColor(0,0,255); break;
  1755.         case 273: Nlm_SelectBackColor(0,255,255); break;
  1756.         case 137: Nlm_SelectBackColor(255,0,255); break;
  1757.         case 69: Nlm_SelectBackColor(255,255,0); break;
  1758.         }
  1759. }
  1760.  
  1761. void DDrawPict::getPenMode()
  1762. {
  1763.     switch (getWord()) {
  1764.         case 0: Nlm_CopyMode(); break;
  1765.         case 1: Nlm_MergeMode(); break;
  1766.         case 2: Nlm_InvertMode(); break;
  1767.         case 3: Nlm_EraseMode(); break;
  1768.         }
  1769. }
  1770.  
  1771.  
  1772. void DDrawPict::handleRectOpcode( word opcode)
  1773. {
  1774.     Nlm_PoinT        pt, pt1;
  1775.  
  1776.     getRectLocal( &fTheRect);
  1777.  
  1778. #if 0
  1779.     Nlm_MoveTo(fTheRect.left,fTheRect.top); /* ?? */
  1780. #endif
  1781.     switch (opcode) {
  1782.         case oframeRect:   if (fPenshown && fUnclipped) Nlm_FrameRect( &fTheRect); break;        
  1783.         case oeraseRect:   if (fUnclipped) Nlm_EraseRect( &fTheRect); break;        
  1784.         case opaintRect:   if (fUnclipped) Nlm_PaintRect( &fTheRect); break;        
  1785.         case oinvertRect:  if (fUnclipped) Nlm_InvertRect( &fTheRect); break;        
  1786.         case ofillRect:    /* setPattern(); Nlm_PaintRect( &fTheRect);*/  break;        
  1787.  
  1788.         case oframeRRect:   if (fPenshown && fUnclipped) Nlm_FrameRoundRect( &fTheRect, fOvSize.x, fOvSize.y); break;        
  1789.         case oeraseRRect:   if (fUnclipped) Nlm_EraseRoundRect( &fTheRect, fOvSize.x, fOvSize.y); break;        
  1790.         case opaintRRect:   if (fUnclipped) Nlm_PaintRoundRect( &fTheRect, fOvSize.x, fOvSize.y); break;        
  1791.         case oinvertRRect:  if (fUnclipped) Nlm_InvertRoundRect( &fTheRect, fOvSize.x, fOvSize.y); break;        
  1792.         case ofillRRect:    /* setPattern(); Nlm_PaintRoundRect( &fTheRect, fOvSize.x, fOvSize.y); */ break;        
  1793.  
  1794.         case oframeOval:   if (fPenshown && fUnclipped) Nlm_FrameOval( &fTheRect); break;        
  1795.         case oeraseOval:   if (fUnclipped) Nlm_EraseOval( &fTheRect); break;        
  1796.         case opaintOval:   if (fUnclipped) Nlm_PaintOval( &fTheRect); break;        
  1797.         case oinvertOval:  if (fUnclipped) Nlm_InvertOval( &fTheRect); break;        
  1798.         case ofillOval:    /* setPattern(); Nlm_PaintOval( &fTheRect); */ break;        
  1799.  
  1800.         case oframeArc:   getAArc(&fTheRect,&pt,&pt1); if (fPenshown && fUnclipped) Nlm_FrameArc( &fTheRect, pt, pt1); break;        
  1801.         case oeraseArc:   getAArc(&fTheRect,&pt,&pt1); if (fUnclipped) Nlm_EraseArc( &fTheRect, pt, pt1); break;        
  1802.         case opaintArc:   getAArc(&fTheRect,&pt,&pt1); if (fUnclipped) Nlm_PaintArc( &fTheRect, pt, pt1); break;        
  1803.         case oinvertArc:  getAArc(&fTheRect,&pt,&pt1); if (fUnclipped) Nlm_InvertArc( &fTheRect, pt, pt1); break;        
  1804.         case ofillArc:    getAArc(&fTheRect,&pt,&pt1); /* setPattern(); Nlm_PaintArc( &fTheRect, pt, pt1); */ break;        
  1805.     }
  1806. }
  1807.  
  1808. void DDrawPict::handleSameRectOpcode( word opcode)
  1809. {
  1810.     Nlm_PoinT        pt, pt1;
  1811.  
  1812.     switch (opcode) {
  1813.  
  1814.         case oframeSameRect:  if (fPenshown && fUnclipped) Nlm_FrameRect( &fTheRect); break;        
  1815.         case oeraseSameRect:  if (fUnclipped) Nlm_EraseRect( &fTheRect); break;        
  1816.         case opaintSameRect:  if (fUnclipped) Nlm_PaintRect( &fTheRect); break;        
  1817.         case oinvertSameRect: if (fUnclipped) Nlm_InvertRect( &fTheRect); break;        
  1818.         case ofillSameRect: /* setPattern(); Nlm_PaintRect( &fTheRect); */ break;        
  1819.  
  1820.         case oframeSameRRect:  if (fPenshown && fUnclipped) Nlm_FrameRoundRect( &fTheRect, fOvSize.x, fOvSize.y); break;        
  1821.         case oeraseSameRRect:  if (fUnclipped) Nlm_EraseRoundRect( &fTheRect, fOvSize.x, fOvSize.y); break;        
  1822.         case opaintSameRRect:  if (fUnclipped) Nlm_PaintRoundRect( &fTheRect, fOvSize.x, fOvSize.y); break;        
  1823.         case oinvertSameRRect: if (fUnclipped) Nlm_InvertRoundRect( &fTheRect, fOvSize.x, fOvSize.y); break;        
  1824.         case ofillSameRRect: /* setPattern(); Nlm_PaintRoundRect( &fTheRect, fOvSize.x, fOvSize.y); */  break;        
  1825.  
  1826.         case oframeSameOval:  if (fPenshown && fUnclipped) Nlm_FrameOval( &fTheRect); break;        
  1827.         case oeraseSameOval:  if (fUnclipped) Nlm_EraseOval( &fTheRect); break;        
  1828.         case opaintSameOval:  if (fUnclipped) Nlm_PaintOval( &fTheRect); break;        
  1829.         case oinvertSameOval: if (fUnclipped) Nlm_InvertOval( &fTheRect); break;        
  1830.         case ofillSameOval: /* setPattern(); Nlm_PaintOval( &fTheRect); */ break;        
  1831.  
  1832.         case oframeSameArc:  getAArc(&fTheRect,&pt,&pt1); if (fPenshown && fUnclipped) Nlm_FrameArc( &fTheRect, pt, pt1); break;        
  1833.         case oeraseSameArc:  getAArc(&fTheRect,&pt,&pt1); if (fUnclipped) Nlm_EraseArc( &fTheRect, pt, pt1); break;        
  1834.         case opaintSameArc:  getAArc(&fTheRect,&pt,&pt1); if (fUnclipped) Nlm_PaintArc( &fTheRect, pt, pt1); break;        
  1835.         case oinvertSameArc: getAArc(&fTheRect,&pt,&pt1); if (fUnclipped) Nlm_InvertArc( &fTheRect, pt, pt1); break;        
  1836.         case ofillSameArc: /* setPattern();  Nlm_PaintArc( &fTheRect, pt, pt1); */ break;        
  1837.  
  1838.         }
  1839. }
  1840.  
  1841.  
  1842.  
  1843. void* DDrawPict::IsPICT( void* pictdata, ulong datasize, Nlm_Boolean dontTestForHeader)
  1844. {    
  1845.     unsigned char        b;
  1846.     Nlm_RecT                aPicFrame;
  1847.     unsigned short    picversion, picSize;
  1848.     
  1849.     if (!pictdata) return NULL;
  1850. TestAgain:
  1851.     fPict=  (byte*) pictdata;
  1852.     picSize= getWord(); 
  1853.     getRectAsis( &aPicFrame);
  1854. #if ANOTHER_POSSIBLE_PICT_TEST
  1855.     if (picSize == 0) goto TestHead; 
  1856.     if (fPicRect.right - fPicRect.left <= 0 
  1857.      || fPicRect.bottom - fPicRect.top <= 0)  
  1858.         goto TestHead;  
  1859. #endif
  1860.  
  1861.     while ((b = getByte()) == 0) ;
  1862.     if (b != 0x011) goto TestHead; //return NULL;
  1863.     b = getByte();
  1864.     switch (b) {
  1865.         case 1:
  1866.             picversion= 1;
  1867.             return pictdata;
  1868.         case 2:
  1869.             picversion = 2;
  1870.             if (getByte() != 0xff) goto TestHead; //return NULL;
  1871.             return pictdata;
  1872.         default:
  1873.             goto TestHead; //return NULL;
  1874.         }
  1875.  
  1876. TestHead:
  1877.     if (dontTestForHeader || datasize<512) 
  1878.         return NULL;
  1879.     else { // skip possible 512-byte MacDraw header...
  1880.         pictdata = (Nlm_VoidPtr) ((unsigned long)pictdata + 512); 
  1881.         datasize -= 512;     
  1882.         dontTestForHeader= TRUE;
  1883.         goto TestAgain;
  1884.         }
  1885.  
  1886. }
  1887.  
  1888.  
  1889. void DDrawPict::GetFrame( Nlm_RectPtr frame, void* pictdata, ulong picsize, short kind)
  1890. {
  1891.     if (!pictdata || !frame) return;
  1892.     if (kind != kPictMac) return;
  1893.     fAlign= 0;
  1894.     fPicsize= picsize;
  1895.     fPict= (byte*) pictdata;
  1896.     short dummyPicSize= getWord();  
  1897.     getRectAsis( &fPicFrame);
  1898.     *frame= fPicFrame;
  1899. }
  1900.  
  1901.  
  1902. void DDrawPict::Draw( Nlm_RectPtr r, void* pictdata, ulong picsize, short kind)
  1903. {
  1904.     /* translator from Apple Quickdraw PICT data format to NCBIDraw methods */
  1905.     /* based on PICT I and II opcodes described in Inside Macintosh vol. V */
  1906.     /* some code from picttoppm.c, Copyright 1993 George Phillips <phillips@cs.ubc.ca> */
  1907.     
  1908.     enum { kMaxBuf = 257 };
  1909.  
  1910.     byte                b, *bp;
  1911.     word                 w, opcode;
  1912.     longword         curpat;
  1913.     short                i, dummyPicSize;
  1914.     Nlm_PoinT        pt, pt1;
  1915.     Nlm_PoinT        curpt; //-- track all moves w/ this?
  1916.     word                 red, green, blue;
  1917.     short                dh, dv;
  1918.     Nlm_Boolean            dorgn, done, clipWasSet, colored;
  1919.     char                *cp, buf[kMaxBuf];
  1920.     
  1921.     Nlm_PointPtr    apoly = NULL;
  1922.     Nlm_RecT        polybox;
  1923.     short                npoly;
  1924.  
  1925.     Nlm_RegioN    argn = NULL;
  1926.     Nlm_RecT        rgnbox;    
  1927.     
  1928.     
  1929.     if (!pictdata) return;
  1930.     if (kind != kPictMac) return;
  1931.     
  1932. #ifdef PLIST
  1933.     char fname[128];
  1934.     strcpy(fname,"work:+PicList-");
  1935.     if (gDoPlist) gPlist= fopen( fname, "w");
  1936. #endif
  1937.  
  1938.     fAlign= 0;
  1939.     fPicsize= picsize;
  1940.     fNeedInstallFont= true;
  1941.     fFontname = "Times"; 
  1942.     fFontfamily = "Roman";
  1943.     fFontsize = 12; 
  1944.     fFontstyle = 0;
  1945.     
  1946.     fPicRect=  *r;
  1947.     fPict= (byte*) pictdata;
  1948.     dummyPicSize= getWord();  
  1949.     getRectAsis( &fPicFrame);
  1950.     clipWasSet= FALSE; 
  1951.     fPenshown= TRUE;
  1952.     fUnclipped = TRUE;
  1953.     curpat= 0;
  1954.     colored= false;
  1955.     Nlm_MoveTo(fPicRect.left,fPicRect.top); /* ?? */
  1956. #ifdef PLIST
  1957.     if (gDoPlist) fprintf(gPlist, "\n global left,top: %d,%d\n",fPicRect.left,fPicRect.top);
  1958.     if (gDoPlist) fprintf(gPlist, " frame  left,top: %d,%d\n",fPicFrame.left,fPicFrame.top);
  1959. #endif
  1960.  
  1961.     while ((b = getByte()) == 0) ;
  1962.     if (b != 0x011) {
  1963.         bp=  (byte*) pictdata;
  1964.         cp= buf;
  1965.         for (i= 0; i<12; i++) { sprintf(cp, "%x%x ", *bp, *(bp+1)); cp += 5; bp += 2; }
  1966.         if (fVerbose) { Nlm_Message(MSG_OK,"drawpict: No version number %s", buf); fVerbose= false; }
  1967.         return;
  1968.         }
  1969.  
  1970.     b = getByte();
  1971.     switch (b) {
  1972.         case 1:
  1973.             fPictVersion= 1;
  1974.             break;
  1975.         case 2:
  1976.             fPictVersion = 2;
  1977.             if (getByte() != 0xff) {
  1978.                 if (fVerbose) { Nlm_Message(MSG_OK,"drawpict: can only do version 2, subcode 0xff"); fVerbose= false; }
  1979.                 return;
  1980.                 }
  1981.             break;
  1982.         default:
  1983.             fPictVersion= 0;
  1984.             bp= (byte*) pictdata;
  1985.             cp= buf;
  1986.             for (i= 0; i<12; i++) { sprintf(cp, "%x%x ", *bp, *(bp+1)); cp += 5; bp += 2; }
  1987.             if (fVerbose) { Nlm_Message(MSG_OK,"drawpict: unknown format %s", buf); fVerbose= false; }
  1988.             return;
  1989.         }
  1990.                 
  1991.     curpt.x= curpt.y= 0;
  1992.     done= false;
  1993.     while (true) { 
  1994.     
  1995.         if (done || (fPicsize && fAlign>=fPicsize)) {
  1996. #ifdef PLIST
  1997.             if (gDoPlist) fprintf(gPlist, "\n\n");
  1998.             fclose(gPlist);
  1999.             if (!done) Nlm_Beep();
  2000. #endif
  2001.             if (argn) argn= Nlm_DestroyRgn(argn);  
  2002.           if (apoly) Nlm_MemFree(apoly);  
  2003.           if (clipWasSet) Nlm_ResetClip();  
  2004.             /* ^^ Nlm_ResetClip IS BAD, can lead to messes, but NCBI Draw hasn't any GetClip() yet*/
  2005.             return;
  2006.             }
  2007.                 
  2008.         opcode= getOpcode();
  2009.  
  2010.         if (fNeedInstallFont && opcode != oTxFont && opcode != oTxFace 
  2011.             && opcode != oTxSize && opcode != oTxMode)  
  2012.             InstallFont();
  2013.             
  2014.         switch (opcode) {
  2015.         
  2016.             case oopEndPic: 
  2017.                 done= true;
  2018.               break; 
  2019.  
  2020.             case oNOP            : break; 
  2021.             case oVersion    : (void) getByte(); break;
  2022.             case oHeaderOp: skipbytes(24); break;
  2023.             
  2024.             case oClip        : 
  2025.                 /* usually 1st pict opcode after header is clip to fPicRect */
  2026.                 /* BUT some picts, a few icons, have this clip offset outside of true drawing rgn !! */
  2027.                 /* whose bug is this */
  2028.                 getARgn(&rgnbox, &argn, TRUE);
  2029. #if 1
  2030.                 //fUnclipped= ( ! Nlm_EmptyRect( &rgnbox));
  2031.                 fUnclipped = (rgnbox.left < rgnbox.right && rgnbox.top < rgnbox.bottom);
  2032. #else
  2033.                 Nlm_ClipRgn(argn); // << leaving unclipped for debugging 
  2034.                 clipWasSet= TRUE; 
  2035. #endif
  2036.                 break;  
  2037.                 
  2038.             case oOvSize    : getPointAsis( &fOvSize);  break;
  2039.             case oOrigin    :     // oOrigin data is dh:word, dv:word
  2040.                 {
  2041.                 short  dh, dv;
  2042.                 dh= (signed short) getWord();
  2043.                 dv= (signed short) getWord();
  2044.                 Nlm_OffsetRect( &fPicFrame, dh, dv);
  2045.                     // we also must move current point...
  2046.                 curpt.x -= dh;
  2047.                 curpt.y -= dv;
  2048.                 Nlm_GetPen( &pt); // bad for X,?MWin?
  2049.                 pt.x -= dh; // this one is bad !? mirror of 
  2050.                 pt.y -= dv;
  2051.                 Nlm_MoveTo( pt.x, pt.y); 
  2052. #ifdef PLIST
  2053.                 if (gDoPlist) {
  2054.                     fprintf( gPlist, " dh,v: %d,%d  or.left,top: %d,%d, pt.x,y %d,%d", 
  2055.                             dh,dv, fPicFrame.left, fPicFrame.top, pt.x, pt.y); 
  2056.                     }
  2057. #endif
  2058.                 
  2059.                 }
  2060.                 break;
  2061.                 
  2062.             case oChExtra    :    (void) getWord(); break;
  2063.             case oPnLocHFrac: (void) getWord(); break;
  2064.     
  2065.             case oBkPat        : skipbytes(8); break;
  2066.             case oFillPat    : skipbytes(8); break;
  2067.             case oPnPat        : 
  2068. #if 1
  2069.                 for (i=0, curpat=0; i<8; i++) {
  2070.                     curpat <<= 1;
  2071.                     curpat += getByte();
  2072.                     }
  2073. #else
  2074.                 skipbytes(8); /* patterns COULD be supported in NCBI draw w/ some extra code */
  2075. #endif
  2076.                 break;
  2077.             case oBkPixPat    : read_pattern(); break;
  2078.             case oPnPixPat    : read_pattern(); break;
  2079.             case oFillPixPat: read_pattern(); break;
  2080.  
  2081.             case oHiliteMode    : break;
  2082.             case oHiliteColor    : skipbytes(6); break;
  2083.             case oDefHilite        : break;
  2084.             case oOpColor            : getRGBKolor( &fOpcolor); break; 
  2085.             case oShortComment: skipbytes(2); break;
  2086.             case oLongComment : 
  2087.                 w= getWord(); /* kind */
  2088.                  w= getWord(); /* size */
  2089.                  skipbytes(w); 
  2090.                  break;
  2091.  
  2092.  
  2093.             case oPackBitsRgn:
  2094.             case oBitsRgn:
  2095.                 dorgn= TRUE;
  2096.                 goto readbits;
  2097.             case oPackBitsRect:
  2098.             case oBitsRect:    
  2099.                 dorgn= FALSE;
  2100.             readbits:
  2101.                 {
  2102.                 word rowbytes= getWord();
  2103.                 if (rowbytes & 0x8000)  
  2104.                     drawPixmap( fPictVersion, rowbytes, dorgn);
  2105.                 else  
  2106.                     drawBitmap( fPictVersion, rowbytes, dorgn);
  2107.                 }
  2108.                 break;
  2109.             case oOpcode9A: drawPixmapOp9A( fPictVersion); break;            
  2110.                 
  2111.                             
  2112.             case oTxFont    : w= getWord(); SetFont(w); break;
  2113.             case oTxFace    : b= getByte(); SetFontStyle(b); break;
  2114.             case oTxSize    : w= getWord(); SetFontSize(w); break;
  2115.             case oTxRatio    : skipbytes(8); break;    
  2116.             case oSpExtra    : skipbytes(4); break;
  2117.             case oTxMode    :    getPenMode();    break;
  2118.                     
  2119.             case oFontName: /* was res2c */
  2120.                 w= getWord();
  2121.                 if (w>3) {
  2122.                     fLastFontnum= getWord();
  2123.                     w -= 2;
  2124.                     b= getByte();
  2125.                     w -= 1 + b;
  2126.                     getbytes( fLastFontname, b); 
  2127.                     fLastFontname[b]= 0;
  2128.                     }
  2129.                 if (w>0) skipbytes(w);                
  2130.                  break;
  2131.             
  2132.             
  2133.             case oPnSize: 
  2134.                 getPointAsis( &pt); 
  2135.                  Nlm_WidePen(pt.x); 
  2136.                  fPenshown= (pt.x != 0);
  2137.                 break;
  2138.             case oPnMode: 
  2139.                 getPenMode();
  2140.                 break;
  2141.             
  2142.                 /* these are PICT 1 oldstyle colors, not translatable to RGB values !! */
  2143.             case oFgColor: 
  2144.                 getForeColor();
  2145.                 colored= true; 
  2146.                 break;
  2147.  
  2148.             case oBkColor: 
  2149.                 getBackColor();
  2150.                 break;
  2151.                 
  2152.             case oRGBFgCol:
  2153.                 /* getRGBKolor( &aColor); */
  2154.                 red= getWord() >> 8; 
  2155.                 green= getWord() >> 8; 
  2156.                 blue= getWord() >> 8;
  2157.                 Nlm_SelectColor(red,green,blue);
  2158.                 colored= true; 
  2159.                 break;
  2160.             case oRGBBkCol:  
  2161.                 red= getWord() >> 8; 
  2162.                 green= getWord() >> 8; 
  2163.                 blue= getWord() >> 8;
  2164.                 Nlm_SelectBackColor(red,green,blue);
  2165.                 break;
  2166.  
  2167.             case oLine:
  2168.                 getPointLocal( &pt); 
  2169.                 getPointLocal( &pt1);
  2170.                 if (fPenshown && fUnclipped) Nlm_DrawLine( pt, pt1);
  2171.                 else Nlm_MoveTo( pt1.x, pt1.y); 
  2172.                 curpt= pt1;
  2173.                 break;
  2174.             case oLineFrom:    
  2175.                 getPointLocal( &pt); 
  2176.                 if (fPenshown && fUnclipped) Nlm_LineTo(pt.x, pt.y);
  2177.                 else Nlm_MoveTo( pt.x, pt.y); 
  2178.                 curpt= pt;
  2179.                 break;
  2180.                 
  2181.             case oShortLine: 
  2182.                 getPointLocal( &pt); 
  2183.                 dh= (signed char) getByte();
  2184.                 dv= (signed char) getByte();
  2185.                 pt1.x = pt.x + dh;
  2186.                 pt1.y = pt.y + dv;
  2187. #if 0
  2188.                 if (fPenshown && fUnclipped) {
  2189.                     Nlm_GetPen( &pt0);
  2190.                     Nlm_DrawLine( pt, pt1);
  2191.                     Nlm_MoveTo( pt0.x, pt0.y); 
  2192.                     }
  2193. #else
  2194.                 if (fPenshown && fUnclipped) Nlm_DrawLine( pt, pt1);
  2195.                 else Nlm_MoveTo( pt1.x, pt1.y); 
  2196.                 //curpt= pt1;                  // !! can't move here or DH/DVText is screwed !!!!
  2197. #endif
  2198.                 break;
  2199.                 
  2200.             case oShortLineFrom:
  2201.                 dh= (signed char) getByte();
  2202.                 dv= (signed char) getByte();
  2203.                 Nlm_GetPen( &pt);  // bad for X,?MWin?
  2204.                 pt1.x= pt.x + dh;
  2205.                 pt1.y= pt.y + dv;
  2206. #if 0
  2207.                 if (fPenshown && fUnclipped) {
  2208.                     Nlm_LineTo( pt1.x, pt1.y);
  2209.                     Nlm_MoveTo( pt.x, pt.y); 
  2210.                     }
  2211. #else
  2212.                 if (fPenshown && fUnclipped) Nlm_LineTo(pt1.x, pt1.y);
  2213.                 else Nlm_MoveTo( pt1.x, pt1.y); 
  2214.                 //curpt= pt1;// !! can't move here or DH/DVText is screwed !!!!
  2215. #endif
  2216.                 break;
  2217.  
  2218.                  
  2219.             case or2e_mov:  /* was r2e -- ?? a moveto??  */
  2220.                 w= getWord();
  2221.                 if (w>0) skipbytes(w);
  2222.                 break;
  2223.  
  2224.             case oLongText:
  2225.                 getPointLocal( &pt); 
  2226.                 curpt= pt;
  2227.                 goto caseDrawString;                
  2228.             case oDHDVText:
  2229.             case oDVText:
  2230.             case oDHText:
  2231. #if 1
  2232.                 pt= curpt;
  2233. #else
  2234.                 Nlm_GetPen( &pt);
  2235. #endif
  2236.                 dh= getByte();
  2237.                 if (opcode == oDHDVText){
  2238.                     pt.x += dh;
  2239.                     dv= getByte();
  2240.                     pt.y += dv;
  2241.                     }
  2242.                 else if (opcode == oDVText) pt.y += dh;
  2243.                 else pt.x += dh;
  2244.             caseDrawString:
  2245.                 Nlm_MoveTo( pt.x, pt.y);
  2246.                 b= getByte();
  2247.                 getbytes( buf, b); 
  2248.                 buf[b]= 0;
  2249. #ifdef PLIST
  2250.                 if (gDoPlist) fprintf( gPlist, " x,y: %d,%d",pt.x, pt.y); 
  2251.                 if (gDoPlist) fprintf( gPlist, " '%s'",buf); 
  2252. #endif
  2253.                 if (fUnclipped) Nlm_PaintString( buf);
  2254.                 Nlm_MoveTo( pt.x, pt.y); // Nlm_PaintString moves to pt.x + stringlen(buf)
  2255.                 curpt= pt;
  2256.                 break;    
  2257.     
  2258.             
  2259.             /* fill...() are disabled until we get setPattern working... */
  2260.             case opaintRect:      
  2261.                 if (!fPenshown && !colored && curpat == 0) opcode= oeraseRect; // quick hack to fix null patterns
  2262.             case oframeRect:      
  2263.             case oeraseRect:       
  2264.             case oinvertRect:     
  2265.             case ofillRect:      
  2266.                     handleRectOpcode( opcode);
  2267.                     break;
  2268.                 
  2269.             case opaintRRect:      
  2270.                 if (!fPenshown && !colored && curpat == 0) opcode= oeraseRRect; // quick hack to fix null patterns
  2271.             case oframeRRect:  
  2272.             case oeraseRRect:      
  2273.             case oinvertRRect: 
  2274.             case ofillRRect:  
  2275.                     handleRectOpcode( opcode);
  2276.                     break;
  2277.  
  2278.             case opaintOval:  
  2279.                 if (!fPenshown && !colored && curpat == 0) opcode= oeraseOval; // quick hack to fix null patterns
  2280.             case oframeOval:      
  2281.             case oeraseOval: 
  2282.             case oinvertOval:     
  2283.             case ofillOval:  
  2284.                     handleRectOpcode( opcode);
  2285.                     break;
  2286.  
  2287.             case opaintArc:      
  2288.                 if (!fPenshown && !colored && curpat == 0) opcode= oeraseArc; // quick hack to fix null patterns
  2289.             case oframeArc:           
  2290.             case oeraseArc:          
  2291.             case oinvertArc:      
  2292.             case ofillArc:  
  2293.                     handleRectOpcode( opcode);
  2294.                     break;
  2295.  
  2296.  
  2297.             case opaintSameRect:      
  2298.                 if (!fPenshown && !colored && curpat == 0) opcode= oeraseSameRect; // quick hack to fix null patterns
  2299.             case oframeSameRect:      
  2300.             case oeraseSameRect:       
  2301.             case oinvertSameRect:      
  2302.             case ofillSameRect: 
  2303.                     handleSameRectOpcode(opcode);
  2304.                     break;
  2305.  
  2306.             case opaintSameRRect:      
  2307.                 if (!fPenshown && !colored && curpat == 0) opcode= oeraseSameRRect; // quick hack to fix null patterns
  2308.             case oframeSameRRect:  
  2309.             case oeraseSameRRect:   
  2310.             case oinvertSameRRect:      
  2311.             case ofillSameRRect:      
  2312.                     handleSameRectOpcode(opcode);
  2313.                     break;
  2314.  
  2315.             case opaintSameOval:      
  2316.                 if (!fPenshown && !colored && curpat == 0) opcode= oeraseSameOval; // quick hack to fix null patterns
  2317.             case oframeSameOval:      
  2318.             case oeraseSameOval:      
  2319.             case oinvertSameOval:        
  2320.             case ofillSameOval:  
  2321.                     handleSameRectOpcode(opcode);
  2322.                     break;
  2323.  
  2324.             case opaintSameArc:      
  2325.                 if (!fPenshown && !colored && curpat == 0) opcode= oeraseSameArc; // quick hack to fix null patterns
  2326.             case oframeSameArc:     
  2327.             case oeraseSameArc:      
  2328.             case oinvertSameArc:          
  2329.             case ofillSameArc: 
  2330.                     handleSameRectOpcode(opcode);
  2331.                     break;
  2332.  
  2333.             case oframePoly:  getAPoly(&polybox, &npoly, &apoly); if (fPenshown && fUnclipped) Nlm_FramePoly( npoly, apoly); break;        
  2334.             case oerasePoly:  getAPoly(&polybox, &npoly, &apoly); if (fUnclipped) Nlm_ErasePoly( npoly, apoly); break;        
  2335.             case opaintPoly:  getAPoly(&polybox, &npoly, &apoly); 
  2336.                     if (fUnclipped) {
  2337.                          if (!fPenshown && !colored && curpat == 0) Nlm_ErasePoly( npoly, apoly);
  2338.                         else Nlm_PaintPoly( npoly, apoly); 
  2339.                         }
  2340.                     break;        
  2341.             case oinvertPoly: getAPoly(&polybox, &npoly, &apoly); if (fUnclipped) Nlm_InvertPoly( npoly, apoly); break;        
  2342.             case ofillPoly:   getAPoly(&polybox, &npoly, &apoly); /* setPattern();  Nlm_PaintPoly( npoly, apoly); */ break;        
  2343.  
  2344.             case oframeSamePoly:  if (fPenshown && fUnclipped) Nlm_FramePoly( npoly, apoly); break;        
  2345.             case oeraseSamePoly:  if (fUnclipped) Nlm_ErasePoly( npoly, apoly); break;        
  2346.             case opaintSamePoly:  
  2347.                     if (fUnclipped) {
  2348.                         if (!fPenshown && !colored && curpat == 0) Nlm_ErasePoly( npoly, apoly);
  2349.                         else Nlm_PaintPoly( npoly, apoly); 
  2350.                         }
  2351.                      break;    
  2352.             case oinvertSamePoly: if (fUnclipped) Nlm_InvertPoly( npoly, apoly); break;        
  2353.             case ofillSamePoly: /* setPattern();  Nlm_PaintPoly( npoly, apoly); */  break;        
  2354.  
  2355.             case oframeRgn:  getARgn(&rgnbox, &argn, FALSE); if (fPenshown && fUnclipped) Nlm_FrameRgn( argn); break;        
  2356.             case oeraseRgn:  getARgn(&rgnbox, &argn, FALSE); if (fUnclipped) Nlm_EraseRgn( argn); break;        
  2357.             case opaintRgn:  getARgn(&rgnbox, &argn, FALSE); 
  2358.                 if (fUnclipped) {
  2359.                     if (!fPenshown && !colored && curpat == 0) Nlm_EraseRgn(argn);
  2360.                     else Nlm_PaintRgn( argn);
  2361.                     }
  2362.                 break;        
  2363.             case oinvertRgn: getARgn(&rgnbox, &argn, FALSE); if (fUnclipped) Nlm_InvertRgn( argn); break;        
  2364.             case ofillRgn:   getARgn(&rgnbox, &argn, FALSE); /* setPattern(); Nlm_PaintRgn( argn); */ break;        
  2365.  
  2366.             case oframeSameRgn:  if (fPenshown && fUnclipped) Nlm_FrameRgn( argn); break;        
  2367.             case oeraseSameRgn:  if (fUnclipped) Nlm_EraseRgn( argn); break;        
  2368.             case opaintSameRgn:  
  2369.                 if (fUnclipped) {
  2370.                     if (!fPenshown && !colored && curpat == 0) Nlm_EraseRgn(argn);
  2371.                     else Nlm_PaintRgn( argn);
  2372.                     }
  2373.                 break;        
  2374.             case oinvertSameRgn: if (fUnclipped) Nlm_InvertRgn( argn); break;        
  2375.             case ofillSameRgn: /* setPattern(); Nlm_PaintRgn( argn); */  break;        
  2376.  
  2377.             case r17: case r18: case r19: break;                
  2378.             case r24: case r25: case r26: case r27:        skipbytes( getWord()); break;
  2379.             case r2d: case r2f: skipbytes( getWord()); break;
  2380.             case r35: case r36: case r37: skipbytes( 8); break;
  2381.             case r3d: case r3e: case r3f: break;
  2382.             case r45: case r46: case r47: skipbytes( 8); break;
  2383.             case r4d: case r4e: case r4f: break;
  2384.             case r55: case r56: case r57: skipbytes( 8); break;
  2385.             case r5d: case r5e: case r5f: break;
  2386.             case r65: case r66: case r67: skipbytes( 12); break;
  2387.             case r6d: case r6e: case r6f: skipbytes( 4); break;
  2388.             case r75: case r76: case r77: skipPolyOrRegion(); break;
  2389.             case r7d: case r7e: case r7f: break;
  2390.             case r85: case r86: case r87: skipPolyOrRegion(); break;
  2391.             case r8d: case r8e: case r8f: break;
  2392.             case r92: case r93: case r94: 
  2393.             case r95: case r96: case r97:    skipbytes( getWord()); break;
  2394.             case r9b: case r9c: case r9d: case r9e: case r9f:    skipbytes( getWord()); break;
  2395.                 
  2396.             default : {
  2397.                 if (opcode >= 0xa2 && opcode <= 0xaf) skipbytes( getWord());
  2398.                 else if (opcode >= 0x0b0 && opcode <= 0x0cf) ; 
  2399.                 else if (opcode >= 0x0d0 && opcode <= 0x0fe)     skipbytes( getLong());
  2400.                 else if (opcode >= 0x100 && opcode <= 0x7fff) skipbytes( (opcode >> 7) & 255);
  2401.                 else if (opcode >= 0x8000 && opcode <= 0x80ff) ; 
  2402.                  else if (opcode >= 0x8100 && opcode <= 0xffff) skipbytes( getLong());
  2403.                 else 
  2404.                     Nlm_Message(MSG_FATAL,"drawpict: don't know opcode %x", opcode);
  2405.                 }
  2406.  
  2407.             }
  2408.         }  
  2409.         
  2410. }
  2411.  
  2412.  
  2413.